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

Question

现在真的需要你的帮助

我有一些检测结果。

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

我的算法逻辑如下

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

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

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

[x,y] 其中 [x,y] 代表我的点

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

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

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

这是我的代码的一部分:

//图像旋转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();
        }
}

Answer 1

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

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