java - 获取正确的多边形以在图像中显示-6ren

java - 获取正确的多边形以在图像中显示

转载作者：行者123 更新时间：2023-12-01 14:46:45

现在真的需要你的帮助

我有一些检测结果。

我希望在这个未旋转的图像上显示这个结果(请忽略蓝色框)

我的算法逻辑如下

鉴于黄色框的坐标是引用引用系(图像1的左上角)，我试图引用顶部的引用系找到黄色框的坐标图像 1 中内部图像的左角。

所以我使用基本的trigno(图像1右下角的直角三角形)来获取内部图像左上角的坐标，并引用该点找到黄色框的坐标。

之后我使用，因为我想在图像2上显示结果，我使用内部图像的中心作为我的旋转点，并将黄色框相对于该中心的坐标平移到内部图像的原点(左上角)并使用此矩阵旋转:

enter image description here [x,y] 其中 [x,y] 代表我的点

我在图像上生成的多边形是这样的:

enter image description here

我的教授看了之后说这是错误的。

我已经记不清我经历了多少次逻辑和实现......这对我来说似乎是正确的。有好心人可以帮帮我吗？

这是我的代码的一部分:

//图像旋转135度的代码

 else if(nameForcompare.equals("135")){
       angle = 225;
       minPoint.set_y(catYmin); minPoint.set_x(catXmin); maxPoint.set_y(catYmax); maxPoint.set_x(catXmax);
       //Show detection results of rotated image
       g5.setColor(Color.YELLOW);
       g5.drawRect((int)minPoint.get_x(), (int)minPoint.get_y(), (int)(maxPoint.get_x()-minPoint.get_x()), (int)(maxPoint.get_y()-minPoint.get_y()));


       rotatedX = Double.parseDouble(originalWidth)*Math.cos(Math.toRadians((int)45));
         if(catXmin < rotatedX){
              o = imageHeight - catYmin;
              a = rotatedX - catXmin;
              theta = Math.atan(o/a);
              h = (o/Math.sin(theta));

           if(theta >= Math.toRadians((int)45)){   
              thetaZ = theta - Math.toRadians((int)45);

              oZ = h*Math.sin(thetaZ); //ycoordinate
              aZ = h*Math.cos(thetaZ); //xcoordinate

              varX = checkPointsBeforeRotationX(aZ);
              varY = checkPointsBeforeRotationY(oZ);
           }
           else{
              thetaZ = Math.toRadians((int)45) - theta;
              oZ = 0;                  //ycoordinate
              aZ = h*Math.cos(thetaZ); //xcoordinate

              varX = checkPointsBeforeRotationX(aZ);
              varY = checkPointsBeforeRotationY(oZ);                  

           }
              minPoint.set_x(varX);
              minPoint.set_y(varY);

         }
         else if(catXmin == rotatedX){
             theta = Math.toRadians((int)45);
             h = imageHeight - catYmin;

             o = h*Math.sin(theta); //ycoordinate
             a = h*Math.cos(theta); //xcoordinate

             varX = checkPointsBeforeRotationX(a);
             varY = checkPointsBeforeRotationY(o);                

             minPoint.set_y(varY);
             minPoint.set_x(varX);
         }
         else if(catXmin > rotatedX){
             a = imageHeight - catYmin;
             o = catXmin - rotatedX;
             theta = Math.atan(o/a);
             h = (o/Math.sin(theta));
        if(theta <= Math.toRadians((int)45)){     
             thetaZ = theta + Math.toRadians((int)45);

             oZ = h*Math.sin(thetaZ); //ycoordinate
             aZ = h*Math.cos(thetaZ); //xcoordinate

             varX = checkPointsBeforeRotationX(aZ);
             varY = checkPointsBeforeRotationY(oZ);
        }
        else{
             thetaZ = Math.toRadians((int)45) - theta;

             oZ = 0;                  //xcoordinate
             aZ = h*Math.cos(thetaZ); //ycoordinate 

             varX = checkPointsBeforeRotationX(oZ);
             varY = checkPointsBeforeRotationY(aZ);

        }
             minPoint.set_x(varX);
             minPoint.set_y(varY);

         }

         if(catXmax < rotatedX){
              o = imageHeight - catYmax;
              a = rotatedX - catXmax;
              theta = Math.atan(o/a);
              h = (o/Math.sin(theta));
         if(theta >= Math.toRadians((int)45)){        
              thetaZ = theta - Math.toRadians((int)45);

              oZ = h*Math.sin(thetaZ); //ycoordinate
              aZ = h*Math.cos(thetaZ); //xcoordinate

              varX = checkPointsBeforeRotationX(aZ);
              varY = checkPointsBeforeRotationY(oZ);
         }
         else{
              thetaZ = Math.toRadians((int)45) - theta;
              oZ = 0;                  //ycoordinate
              aZ = h*Math.cos(thetaZ); //xcoordinate

              varX = checkPointsBeforeRotationX(aZ);
              varY = checkPointsBeforeRotationY(oZ);  
         }
              maxPoint.set_x(varX);
              maxPoint.set_y(varY);

         }
         else if(catXmax == rotatedX){
             theta = Math.toRadians((int)45);
             h = imageHeight - catYmin;

             o = h*Math.sin(theta); //ycoordinate
             a = h*Math.cos(theta); //xcoordinate

             varX = checkPointsBeforeRotationX(a);
             varY = checkPointsBeforeRotationY(o); 

             maxPoint.set_y(varY);
             maxPoint.set_x(varX);

         }
         else if(catXmax > rotatedX){
             a = imageHeight - catYmax;
             o = catXmax - rotatedX;
             theta = Math.atan(o/a);
             h = (o/Math.sin(theta));
        if(theta <= Math.toRadians((int)45)){      
             thetaZ = theta + Math.toRadians((int)45);

             oZ = h*Math.sin(thetaZ); //ycoordinate
             aZ = h*Math.cos(thetaZ); //xcoordinate

             varX = checkPointsBeforeRotationX(aZ);
             varY = checkPointsBeforeRotationY(oZ);
        }
        else{
             thetaZ = Math.toRadians((int)45) - theta;

             oZ = 0;                  //xcoordinate
             aZ = h*Math.cos(thetaZ); //ycoordinate 

             varX = checkPointsBeforeRotationX(oZ);
             varY = checkPointsBeforeRotationY(aZ);
        }

             maxPoint.set_y(varX);
             maxPoint.set_x(varY);

         }

        getCorners();
        checkPointsAfterRotation(angle);
        checkCornerPointsAfterRotation(angle);

        g2.setColor(Color.MAGENTA);
        g2.drawPolygon(xPoints, yPoints, nPoints);  
        Corners1 =0; Corners2 =0;








public static void rotate2(Point originForRotation, Point pointForRotation, Double angle){
double cos=Math.cos(angle);
double sin=Math.sin(angle);
double oX =originForRotation.get_x();
double oY =originForRotation.get_y(); 
double x=pointForRotation.get_x();
double y=pointForRotation.get_y(); 

x = x-oX;    y = y-oY; 


pointForRotation.set_x((cos*x-sin*y)+oX);
pointForRotation.set_y((sin*x+cos*y)+oY);    

pointForRotation.show();

}

public static void getCorners(){
    if((minPoint.get_x() > maxPoint.get_x()) && (minPoint.get_y() < maxPoint.get_y())){
      topleftPoint.set_x(maxPoint.get_x());  bottomrightPoint.set_x(minPoint.get_x());
      topleftPoint.set_y(minPoint.get_y());  bottomrightPoint.set_y(maxPoint.get_y());
      Corners1 = 1; 
    }
    else if((minPoint.get_x() > maxPoint.get_x()) && (minPoint.get_y() > maxPoint.get_y())){
      toprightPoint.set_x(minPoint.get_x());  bottomleftPoint.set_x(maxPoint.get_x());
      toprightPoint.set_y(maxPoint.get_y());  bottomleftPoint.set_y(minPoint.get_y());
      Corners2 = 1;
    }
    else if((minPoint.get_x() < maxPoint.get_x()) && (minPoint.get_y() < maxPoint.get_y())){
      toprightPoint.set_x(maxPoint.get_x());  bottomleftPoint.set_x(minPoint.get_x());
      toprightPoint.set_y(minPoint.get_y());  bottomleftPoint.set_y(maxPoint.get_y());
      Corners2 = 1;
    }
    else if((minPoint.get_x() < maxPoint.get_x()) && (minPoint.get_y() > maxPoint.get_y())){
      topleftPoint.set_x(minPoint.get_x());  bottomrightPoint.set_x(maxPoint.get_x());
      topleftPoint.set_y(maxPoint.get_y());  bottomrightPoint.set_y(minPoint.get_y());
      Corners1 = 1;
    }
}

public static Double checkPointsBeforeRotationX(Double pointX){
    if(pointX > (Double.parseDouble(originalWidth))){
      pointX = Double.parseDouble(originalWidth);
      }
    return pointX;
}

public static Double checkPointsBeforeRotationY( Double pointY){
    if(pointY > (Double.parseDouble(originalHeight))){
      pointY = Double.parseDouble(originalHeight);
    }
    return pointY;
}

public static void checkPointsAfterRotation(int angle){

        rotate2(origin, minPoint,  Math.toRadians((int)angle));    
        rotate2(origin, maxPoint,  Math.toRadians((int)angle)); 
         //check for out of bound points after rotation
            if(minPoint.get_y()< 0){
                minPoint.set_y(0);
            }
            else if(minPoint.get_y() > Double.parseDouble(originalHeight)){
                minPoint.set_y(Double.parseDouble(originalHeight));
            }
            if(minPoint.get_x()< 0){
                minPoint.set_x(0);
            }
            else if(minPoint.get_x() > Double.parseDouble(originalWidth)){
                minPoint.set_x(Double.parseDouble(originalWidth));
            }
            if(maxPoint.get_y()< 0){
                maxPoint.set_y(0);
            }
            else if(maxPoint.get_y() > Double.parseDouble(originalHeight)){
                maxPoint.set_y(Double.parseDouble(originalHeight));
            }
            if(maxPoint.get_x()< 0){
                maxPoint.set_x(0);
            }
            else if(maxPoint.get_x() > Double.parseDouble(originalWidth)){
                maxPoint.set_x(Double.parseDouble(originalWidth));
            }

        xPoints[0] = (int)minPoint.get_x(); 
        xPoints[2] = (int)maxPoint.get_x(); 

        yPoints[0] = (int)minPoint.get_y(); 
        yPoints[2] = (int)maxPoint.get_y(); 


}


 public static void checkCornerPointsAfterRotation(int angle){

    if(Corners1 == 0 && Corners2 == 1){

        rotate2(origin, toprightPoint,  Math.toRadians((int)angle));    
        rotate2(origin, bottomleftPoint,  Math.toRadians((int)angle));

        if(toprightPoint.get_y()< 0){
                toprightPoint.set_y(0);
            }
            else if(toprightPoint.get_y() > Double.parseDouble(originalHeight)){
                toprightPoint.set_y(Double.parseDouble(originalHeight));
            }
            if(toprightPoint.get_x()< 0){
                toprightPoint.set_x(0);
            }
            else if(toprightPoint.get_x() > Double.parseDouble(originalWidth)){
                toprightPoint.set_x(Double.parseDouble(originalWidth));
            }
            if(bottomleftPoint.get_y()< 0){
                bottomleftPoint.set_y(0);
            }
            else if(bottomleftPoint.get_y() > Double.parseDouble(originalHeight)){
                bottomleftPoint.set_y(Double.parseDouble(originalHeight));
            }
            if(bottomleftPoint.get_x()< 0){
                bottomleftPoint.set_x(0);
            }
            else if(bottomleftPoint.get_x() > Double.parseDouble(originalWidth)){
                bottomleftPoint.set_x(Double.parseDouble(originalWidth));
            }

            xPoints[1] = (int)toprightPoint.get_x(); xPoints[3] = (int)bottomleftPoint.get_x();
            yPoints[1] = (int)toprightPoint.get_y(); yPoints[3] = (int)bottomleftPoint.get_y();
        }
        else if(Corners1 == 1 && Corners2 == 0){


        rotate2(origin, topleftPoint,  Math.toRadians((int)angle));    
        rotate2(origin, bottomrightPoint,  Math.toRadians((int)angle));    

        if(topleftPoint.get_y()< 0){
                topleftPoint.set_y(0);
            }
            else if(topleftPoint.get_y() > Double.parseDouble(originalHeight)){
                topleftPoint.set_y(Double.parseDouble(originalHeight));
            }
            if(topleftPoint.get_x()< 0){
                topleftPoint.set_x(0);
            }
            else if(topleftPoint.get_x() > Double.parseDouble(originalWidth)){
                topleftPoint.set_x(Double.parseDouble(originalWidth));
            }
            if(bottomrightPoint.get_y()< 0){
                bottomrightPoint.set_y(0);
            }
            else if(bottomrightPoint.get_y() > Double.parseDouble(originalHeight)){
                bottomrightPoint.set_y(Double.parseDouble(originalHeight));
            }
            if(bottomrightPoint.get_x()< 0){
                bottomrightPoint.set_x(0);
            }
            else if(bottomrightPoint.get_x() > Double.parseDouble(originalWidth)){
                bottomrightPoint.set_x(Double.parseDouble(originalWidth));
            } 

            xPoints[1] = (int)topleftPoint.get_x(); xPoints[3] = (int)bottomrightPoint.get_x();
            yPoints[1] = (int)topleftPoint.get_y(); yPoints[3] = (int)bottomrightPoint.get_y();
        }
}

最佳答案

代码太多，无法详细跟踪，但我假设您的代码忠实地实现了您所描述的数学。我认为问题在于您正在应用纯旋转矩阵。从旋转的小猫到旋转的黄色盒子的变换是平移和旋转的组合。您需要首先将小猫(和黄色框)从 (x,y) 平移到 (0,0)(因此旋转后的小猫图像位于图 1 左上角的小猫左上角)。然后你需要将所有东西顺时针旋转 135 度。

使用齐次坐标和矩阵乘法将使您的代码变得更加简单。

关于java - 获取正确的多边形以在图像中显示，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15376542/

文章推荐： java - 从服务器获取所有信息还是分阶段获取？

文章推荐： PDFBox UTF16 字母

文章推荐： c++ - 为什么这段代码在 valgrind (helgrind) 下失败？

javascript - 如果输入 a 或 b 正确/正确，我如何执行操作？
这个问题已经有答案了: How to do case insensitive string comparison? (23 个回答) 已关闭 3 年前。用户在我的输入栏中写入“足球”，然后执行第 6
javascript - 字符 id= + 是 + 正确= + 正确不正确...我怎样才能使它成为 javascript 中的字符串
啊，不习惯 javascript 中的字符串。 character_id= + id + correct= + correctOrIncorrect 这就是我需要制作成字符串的内容。如果您无法猜测字符
javascript - jQuery计算价格不起作用(正确)
$(function() { var base_price = 0; CalculatePrice(); $(".math1").on('change', function(e) { Calc
kubernetes - 将Spinnaker部署到Spinnaker将管理的同一kubernetes集群是否安全/正确？
我找不到任何文章回答问题:将Spinnaker部署到Spinnaker将管理的同一Kubernetes集群是否安全/正确？我主要是指生产，HA部署。最佳答案我认为Spinnaker和Kuberne
c++ - 正确/快速的方法来更改命令行Qt5源内部版本的配置
我正在使用MSVC在Windows上从源代码(官方源代码发布，而不是从仓库中)构建Qt5(Qt 5.15.0)。我正在设置环境。变量，依赖项等，然后运行具有1600万个选项的configure，最后
java - 计数时数组越界[正确]
我需要打印一个包含重复单词的数组。我的数组已经可以工作，但我不知道如何正确计算单词数。我已经知道，当我的索引计数器 (i) 为 49 时，并且当 (i) 想要计数到 50 时，我会收到错误，但我不知道
javascript - 正确/错误取决于屏幕尺寸动态？
我正在遵循一个指南，该指南允许 Google map 屏幕根据屏幕尺寸禁用滚动。我唯一挣扎的部分是编写一个代码，当我手动调整屏幕大小时动态更改 True/False 值。这是我按照说明操作的网站，但
java - 未调用子类中的方法(正确)
我有一个类“FileButton”。它的目的是将文件链接到 JButton，FileButton 继承自 JButton。子类继承自此以使用链接到按钮的文件做有用的事情。 JingleCardButt
php - 如何仅显示来自好友列表的帖子。 (正确)
我的 friend 数组只返回一个数字而不是所有数字。 ($myfriends = 3) 应该是…… ($myfriends = 3 5 7 8 9 12). 如果我让它进入 while 循环……整个
html - 在这种情况下使用整数作为类名是否可以接受/正确
这个问题在这里已经有了答案: Is there a workaround to make CSS classes with names that start with numbers valid?
javascript - 在窗口更改时自动调整元素大小(正确)
我正在制作一个 JavaScript 函数，当调整窗口大小时，它会自动将 div 的大小调整为与窗口相同的宽度/高度。该功能非常基本，但我注意到在调整窗口大小时出现明显的“绘制”滞后。在 JS fi
javascript - 删除导航栏的类 - 正确
此问题的基本视觉效果可在 http://sevenx.de/demo/bootstrap-carousel/inc.carousel/tabbed-slider.html 获得。 - 如果你想看一看。
c - 从将其内存分配给同一函数的函数返回字符串是否安全/正确？
我明白，如果我想从函数返回一个字符串文字或一个数组，我应该将其声明为静态的，这样当被调用的函数被返回时，内容就不会“消亡”。但我的问题是，当我在函数内部使用 malloc 分配内存时会怎样？在下面
mysql - 正确/错误值的适当数据字段类型？
在 mySQL 数据库中存储 true/false/1/0 值最合适(读取数据消耗最少)的数据字段是什么？我以前使用过一个字符长的 tinyint，但我不确定它是否是最佳解决方案？谢谢! 最佳答案
c++ - 正确，有效地读取文件
我想一次读取并处理CSV文件第一行中的条目(例如打印)。我假设使用Unix风格的\n换行符，没有条目长度超过255个字符，并且(现在)在EOF之前有一个换行符。这意味着它是fgets()后跟strto
c++ - “正确”无符号整数比较
所以，我们都知道 -1 > 2u == true 的 C/C++ 有符号/无符号比较规则，并且我有一种情况，我想有效地实现“正确”比较。我的问题是，考虑到人们熟悉的尽可能多的架构，哪种方法更有效。显
Java异常处理：如何写出“正确”但被编译器认为有语法错误的程序
**摘要：**文章的标题看似自相矛盾。本文分享自华为云社区《Java异常处理：如何写出“正确”但被编译器认为有语法错误的程序》，作者： Jerry Wang 。文章的标题看似自相矛盾，然而我在“正
r - 进行按行替换的“正确”方法
我有一个数据框，看起来像: dataDemo % mutate_each(funs(ifelse(. == '.', REF, as.character(.))), -POS) # POS REF
text - VBScript 正确/重新格式化带分隔符的文本文件？
有人可以帮助我使用 VBScript 重新格式化/正确格式化带分隔符的文本文件吗？我有一个文本文件 ^分界如下: AGREE^NAME^ADD1^ADD2^ADD3^ADD4^PCODE^BAL^A
java - 语言认证以及诸如适当、正确、合法等术语的使用
就目前而言，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引起辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visit the he

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

java - 获取正确的多边形以在图像中显示