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

现在确实需要您的帮助获取正确的多边形以在图像中显示

我有一些检测结果。

，我希望表现出这种非旋转图像这个结果（请忽略蓝色框）

我对我的算法逻辑如下

鉴于黄色框的坐标是参照参考框架（图1的左上角），我试图找到黄色框的坐标，参考框架图像1内部图像的左上角的参考。

所以我使用了基本的trigno（图像1右下角的直角三角形，以获得图像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(); 
     } 
}

来源

2013-03-13 user1968818

用于旋转图像的代码太过分了代码详细跟踪过，但我会假设你的代码忠实工具你描述的数学。我认为问题在于你正在应用一个纯旋转矩阵。从旋转的小猫到旋转的黄色框的转变是翻译和旋转的组合。您需要首先将kitty（和黄色框）从（x，y）转换为（0,0）（因此旋转后的kitty图像位于图1左上角的kitty左上角）。然后你需要顺时针旋转135度。

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

来源

2013-03-13 03:38:12

如果你错过了，我解释说我的算法实际上同时使用平移和旋转。然而，不是你建议的，我找到了我的小猫图像的中心，并将它翻译为图1的左上角，并且中心周围的黄色框的坐标也被翻译。之后，我将图像逆时针旋转225度。这是否与你建议的一样？ – user1968818 2013-03-13 03:49:41

@ user1968818 - 我建议将小猫图片的左上角翻译为图1的左上角。我忽略提到旋转应该在图1的左上角左右;我认为这是原点。如果您翻译中心，那么如果您将中心翻译回旋转后应该出现的位置，这将起作用。（否则，小猫形象将最终集中在图1的左上角。） – 2013-03-13 05:32:31

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

回答

相关问题