예제 #1
0
void EastArrowObjectImp::orient()
{
   if (isOriented() == true)
   {
      return;
   }

   GraphicLayer* pLayer = NULL;
   pLayer = getLayer();
   if (pLayer == NULL)
   {
      return;
   }

   View* pView = NULL;
   pView = pLayer->getView();
   if (pView == NULL)
   {
      return;
   }

   SpatialDataView* pSpatialDataView = NULL;
   if (pView->isKindOf("SpatialDataView") == true)
   {
      pSpatialDataView = static_cast<SpatialDataView*> (pView);
   }
   else if (pView->isKindOf("ProductView") == true)
   {
      ProductView* pProductView = static_cast<ProductView*> (pView);

      GraphicLayer* pLayoutLayer = NULL;
      pLayoutLayer = pProductView->getLayoutLayer();
      if (pLayoutLayer == pLayer)
      {
         list<GraphicObject*> viewObjects;
         pLayoutLayer->getObjects(VIEW_OBJECT, viewObjects);

         list<GraphicObject*>::iterator iter = viewObjects.begin();
         while (iter != viewObjects.end())
         {
            GraphicObject* pObject = *iter;
            if (pObject != NULL)
            {
               View* pObjectView = pObject->getObjectView();
               if (pObjectView != NULL)
               {
                  if (pObjectView->isKindOf("SpatialDataView") == true)
                  {
                     pSpatialDataView = static_cast<SpatialDataView*> (pObjectView);
                  }
               }
            }

            ++iter;
         }
      }
   }

   if (pSpatialDataView == NULL)
   {
      return;
   }

   LayerList* pLayerList = pSpatialDataView->getLayerList();
   VERIFYNRV(pLayerList != NULL);
   RasterElement* pRaster = pLayerList->getPrimaryRasterElement();
   VERIFYNRV(pRaster != NULL);
   if (!pRaster->isGeoreferenced())
   {
      return;
   }

   // Calculate the angle of the object relative to the pixel coordinates
   updateHandles();

   LocationType pixelStart = mHandles[7];

   ProductView* pProductView = dynamic_cast<ProductView*> (pView);
   if (pProductView != NULL)
   {
      // Convert to the screen coordinate system
      double dScreenX = 0;
      double dScreenY = 0;
      pLayer->translateDataToWorld(pixelStart.mX, pixelStart.mY, pixelStart.mX, pixelStart.mY);
      pProductView->translateWorldToScreen(pixelStart.mX, pixelStart.mY, dScreenX, dScreenY);
      
      // Convert to the spatial data view coordinate system
      pSpatialDataView->translateScreenToWorld(dScreenX,
         dScreenY, pixelStart.mX, pixelStart.mY);
      pLayer->translateWorldToData(pixelStart.mX, pixelStart.mY, pixelStart.mX, pixelStart.mY);
   }

   double dAngle;
   if (GeoAlgorithms::getAngleToNorth(pRaster, dAngle, pixelStart) == false)
   {
      return;
   }

   // Update the angle if the object is in the layout layer
   if (pProductView != NULL)
   {
      // Rotation
      dAngle -= pSpatialDataView->getRotation();

      // Pitch
      double dPitch = pSpatialDataView->getPitch();
      if (dPitch > 0.0)
      {
         dAngle *= -1.0;
      }
   }

   // Rotate the object
   setRotation(dAngle);

   // Update the orientation flag
   DirectionalArrowObjectImp::orient();
}
예제 #2
0
void MeasurementObjectImp::draw(double zoomFactor) const
{
   const_cast<MeasurementObjectImp*>(this)->updateGeoreferenceAttachment();

   // Verify that factor values are valid
   if ((mArrowRelStartLoc < 0.0) || (mArrowRelStartLoc > mArrowRelEndLoc) || (mArrowRelStartLoc > 1.0) ||
      (mArrowRelEndLoc < 0.0) || (mArrowRelEndLoc > 1.0) || (mBarEndLength < 0))
   {
      return;
   }
    
   // Draw the main line
   LineObjectImp::draw(zoomFactor);
   
   // Get the current view 
   SpatialDataView* pView = NULL;

   MeasurementLayerImp* pLayer = dynamic_cast<MeasurementLayerImp*>(getLayer());
   if (pLayer != NULL)
   {
      pView = dynamic_cast<SpatialDataView*>(pLayer->getView());
   }

   if (pView == NULL)
   {
      return;
   }

   // Misc Variables
   LocationType junkLocation;    // junk variable used to call methods that require unneeded parameters
   double startPerc = 0.0;       // The relative start location along a line to start drawing
   double lineLength = 0;        // The length of the main line
   double pixelSize = 0;         // The number of screen pixels in a scene pixel
   double lineWidth = 0;         // The width of the main line
   double sqrtLineWidth = 0;     // The square root of the line width
   LocationType llCorner;        // lower left corner of annotation bounding box
   LocationType urCorner;        // upper right corner of annotation bounding box
   ColorType textColor;          // The color to draw the text
   ColorType lineColor;          // The color to draw the line
   ColorType fillColor;          // The color to draw the stippled line

   // Misc Calculations
   pixelSize = DrawUtil::getPixelSize(junkLocation.mX, junkLocation.mY, junkLocation.mX, junkLocation.mY);
   llCorner = getLlCorner();
   urCorner = getUrCorner();
   lineWidth = getLineWidth();
   sqrtLineWidth = sqrt(lineWidth);
   textColor = getTextColor();
   lineLength = sqrt(pow(abs(urCorner.mX - llCorner.mX), 2) + pow(abs(urCorner.mY - llCorner.mY), 2));
   lineColor = getLineColor();
   fillColor = getFillColor();

   // Get text font info (used for all text, set to italic if using inaccurate extrapolation)
   QFont font = getFont();
   font.setItalic(mUsingInaccurateGeocoords);

   // Calculate arrow info (line only)
   LocationType arrowStartPoint; // The start point of the arrow line
   LocationType arrowEndPoint;   // The end point of the arrow line
   double arrowOffset = 0;       // Normal offset from main line to arrow
   double arrowLength = 0;       // The length of the arrow line (in pixels)
   arrowOffset = (pixelSize == 0.0) ? 0.0 : mArrowOffset * sqrtLineWidth / pixelSize;
   DrawUtil::getParallelLine(llCorner, urCorner, arrowOffset, mArrowRelStartLoc, mArrowRelEndLoc,
      arrowStartPoint, arrowEndPoint);
   arrowLength = sqrt(pow(abs(arrowEndPoint.mX - arrowStartPoint.mX), 2) + 
      pow(abs(arrowEndPoint.mY - arrowStartPoint.mY), 2));

   // Calculate arrow head info (Only half arrow head is drawn)
   LocationType arrowHeadBasePoint; // Location of arrow head base point
   double arrowHeadOffset = 0;      // Perpendicular offset from arrow line to arrow head base
   arrowHeadOffset = (pixelSize == 0.0) ? 0.0 : (mArrowHeadOffset * sqrtLineWidth) / pixelSize;
   
   // Adjust arrow head size if arrow length becomes smaller then arrow head length.
   while (arrowHeadOffset > arrowLength)
   {  // Since arrow head is at 45 degree angle, arrowHeadOffset is same as arrow head length

      // Adjust size of arrow head
      if (arrowHeadOffset >= 1)
      {
         arrowHeadOffset -= 1;
      }
      else if (arrowHeadOffset > .2)
      {
         arrowHeadOffset = arrowHeadOffset - .1;
      }
      else
      {
         break;
      }
      arrowHeadOffset = (arrowHeadOffset < 0) ? 0.0 : arrowHeadOffset;
   }
   
   // Get arrow head base point coordinates from calculated arrow head info
   startPerc = (arrowLength == 0.0) ? 0.0 : 1 - (arrowHeadOffset/arrowLength);
   startPerc = (startPerc < 0.0) ? 0.0 : startPerc;
   startPerc = (startPerc > 1.0) ? 1.0 : startPerc;
   DrawUtil::getParallelLine(arrowStartPoint, arrowEndPoint, arrowHeadOffset, startPerc, 1.0f,
                             arrowHeadBasePoint, junkLocation);

   // End bar coordinates
   LocationType barStartPoint1;
   LocationType barStartPoint2;     // The points that make up the start bar-end (ll corner)
   LocationType barEndPoint1;
   LocationType barEndPoint2;       // The points that make up the end bar-end (ur corner)
   double barLength = 0;            // Bar-ends length
   barLength = (pixelSize == 0.0) ? 0.0 : (mBarEndLength * sqrtLineWidth) / pixelSize;
   DrawUtil::getPerpendicularLine(llCorner, urCorner, barLength, barStartPoint1, barStartPoint2);
   DrawUtil::getPerpendicularLine(urCorner, llCorner, barLength, barEndPoint1, barEndPoint2);

   // Calculate text info
   double textOffset = 0;     // Perpendicular offset from text to text anchor
   int maxTextureSize = 0;    // The max allowable texture size
   textOffset = (pixelSize == 0.0) ? 0.0 : (mTextOffset * sqrtLineWidth) / pixelSize;
   glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
   QFontMetrics ftMetrics(font);
  
   double viewRotation = pView->getRotation();
   viewRotation = GeoConversions::convertDegToRad(viewRotation);

   if (mDrawnDistanceUnit != pLayer->getDistanceUnits() ||
      mDrawnGeocoord != pLayer->getGeocoordType() ||
      mDrawnDmsFormat != pLayer->getGeoFormat())
   {
      refreshGeoInformation(); // only modifies cache stuff
   }

   if (pLayer->getDisplayEndPoints())
   {
      // Calculate start and end text info
      bool startLocDrawTop = false; // Whether to draw the start lat/lon text on the top of the specified point
      bool endLocDrawTop = true;    // Whether to draw the end lat/lon text on the top of the specified point
      if (urCorner.mY < llCorner.mY)
      {
         startLocDrawTop = true;
         endLocDrawTop = false;
      }

      // Calculate start and end location text info
      LocationType startLocPoint;   // The location to display the "start location" text
      LocationType endLocPoint;     // The location to display the "end location" text
      startLocPoint = llCorner;
      endLocPoint = urCorner;
      startLocPoint.mY += textOffset;
      endLocPoint.mY += textOffset;

      if (!mStartLocText.isEmpty())
      {
         DrawUtil::drawRotatedText(mStartLocTextTexture, mStartLocText, font,
            textColor, startLocPoint, viewRotation, startLocDrawTop);
      }
      if (!mEndLocText.isEmpty())
      {
         DrawUtil::drawRotatedText(mEndLocTextTexture, mEndLocText, font,
            textColor, endLocPoint, viewRotation, endLocDrawTop);
      }
   }
   
   if (pLayer->getDisplayBearing())
   {
      // Calculate bearing text info
      LocationType bearingTextStartPoint; // The location to display the bearing text
      LocationType bearingTextEndPoint;   // The pseudo end location of the baring text (only used to calculate angle)
      double bearingTextTheta = 0;        // Angle (in radians) of bearing text
      bool bearingDrawTop = false;        // The vertical origin to draw text from (True = top, False = bottom)
      QRect bearingTextBoundingBox;       // Bounding box surrounding the bearing text
      bearingTextBoundingBox = ftMetrics.boundingRect(0, 0, maxTextureSize, maxTextureSize, 
         Qt::AlignLeft | Qt::TextWordWrap, mBearingText);
      if (arrowEndPoint.mX < arrowStartPoint.mX)   // To the left of the origin (text underneath line)
      {
         startPerc = ((pixelSize == 0.0) || (arrowLength == 0.0)) ? 0.0 :
            1.0 - (bearingTextBoundingBox.width()/pixelSize)/arrowLength;
         startPerc = (startPerc < 0.0) ? 0.0 : startPerc;
         startPerc = (startPerc > 1.0) ? 1.0 : startPerc;
         DrawUtil::getParallelLine(arrowEndPoint, arrowStartPoint, (-1) * textOffset, startPerc, 1.0f,
            bearingTextStartPoint, bearingTextEndPoint);
         bearingDrawTop = true;
      } 
      else   // To the right of the origin (text on top of the line)
      {
         DrawUtil::getParallelLine(arrowStartPoint, arrowEndPoint, textOffset, 0.0f, 1.0f,
            bearingTextStartPoint, bearingTextEndPoint);
         bearingDrawTop = false;
      }
      bearingTextTheta = ((bearingTextEndPoint.mX - bearingTextStartPoint.mX) == 0.0) ? 0.0 :
         atan((bearingTextEndPoint.mY - bearingTextStartPoint.mY) /
         (bearingTextEndPoint.mX - bearingTextStartPoint.mX));

      if (!mBearingText.isEmpty())
      {
         DrawUtil::drawRotatedText(mBearingTextTexture, mBearingText, font,
            textColor, bearingTextStartPoint, bearingTextTheta, bearingDrawTop);
      }  
   }
   
   if (pLayer->getDisplayDistance())
   {
      // Calculate distance text info
      LocationType distanceTextStartPoint;   // The location to display the distance text
      LocationType distanceTextEndPoint;     // The pseudo end location of the distance text (only used to calculate
                                             // angle)
      double distanceTextTheta = 0;          // Angle (in radians) of distnace text
      bool distanceDrawTop = false;          // The vertical origin to draw text from (True = top, False = bottom)
      double distanceTextWidth = 0;          // The width of the ditance text bounding box (in screen pixels)
      QRect distanceTextBoundingBox;         // Bounding box that surrounds the distance text
      distanceTextBoundingBox = ftMetrics.boundingRect(0, 0, maxTextureSize, maxTextureSize, 
         Qt::AlignLeft | Qt::TextWordWrap, mDistanceText);
      distanceTextWidth = distanceTextBoundingBox.width();
      if ((pixelSize == 0.0) || (lineLength == 0.0))
      {
         startPerc = 0.0;
      } 
      else
      {
         if (urCorner.mX < llCorner.mX)
         {
            startPerc = .5 + (distanceTextWidth/pixelSize/2)/lineLength;
            distanceDrawTop = false;
         }
         else
         {
            startPerc = .5 - (distanceTextWidth/pixelSize/2)/lineLength;
            distanceDrawTop = true;
         }
      }
      startPerc = (startPerc < 0.0) ? 0.0 : startPerc;
      startPerc = (startPerc > 1.0) ? 1.0 : startPerc;
      DrawUtil::getParallelLine(llCorner, urCorner, (-1) * textOffset, startPerc, 1.0f, distanceTextStartPoint,
         distanceTextEndPoint);
      if (lineLength < (distanceTextBoundingBox.width()/pixelSize))
      {
         if (urCorner.mX < llCorner.mX)
         {
            DrawUtil::getParallelLine(llCorner, urCorner, (-1) * textOffset, 0.0f, 1.0f, distanceTextEndPoint,
               distanceTextStartPoint);
         } 
         else
         {
            DrawUtil::getParallelLine(llCorner, urCorner, (-1) * textOffset, 0.0f, 1.0f, distanceTextStartPoint,
               distanceTextEndPoint);
         }

      }
      distanceTextTheta = ((distanceTextEndPoint.mX - distanceTextStartPoint.mX) == 0.0) ? 0.0 :
         atan((distanceTextEndPoint.mY - distanceTextStartPoint.mY) /
         (distanceTextEndPoint.mX - distanceTextStartPoint.mX));

      if (!mDistanceText.isEmpty())
      {
         DrawUtil::drawRotatedText(mDistanceTextTexture, mDistanceText, font,
            textColor, distanceTextStartPoint, distanceTextTheta, distanceDrawTop);
      }
   }

   // GL options
   glLineWidth(lineWidth);
   #if defined(WIN_API)
      glEnable(GL_LINE_SMOOTH);
   #else
      if (lineWidth == 1.0)
      {
         glEnable(GL_LINE_SMOOTH);
      }
      else
      {
         glDisable(GL_LINE_SMOOTH);
      }
   #endif
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   glColor3ub(lineColor.mRed, lineColor.mGreen, lineColor.mBlue);
   
   // Draw the end bar
   glBegin(GL_LINE_STRIP);
   glVertex2d(barEndPoint1.mX, barEndPoint1.mY);
   glVertex2d(barEndPoint2.mX, barEndPoint2.mY);
   glEnd();

   // Draw the start bar
   glBegin(GL_LINE_STRIP);
   glVertex2d(barStartPoint1.mX, barStartPoint1.mY);
   glVertex2d(barStartPoint2.mX, barStartPoint2.mY);
   glEnd();

   // Draw the arrow if bearing is displayed
   if (pLayer->getDisplayBearing())
   {
      glBegin(GL_LINE_STRIP);
      glVertex2d(arrowStartPoint.mX, arrowStartPoint.mY);
      glVertex2d(arrowEndPoint.mX, arrowEndPoint.mY);
      glVertex2d(arrowHeadBasePoint.mX, arrowHeadBasePoint.mY);
      glEnd();
   }

   // Set GL options to draw stippled line (Main line)
   glEnable(GL_LINE_STIPPLE);
   glLineStipple(3, 0xf0f0);
   glColor3ub(fillColor.mRed, fillColor.mGreen, fillColor.mBlue);

   // Draw the stippled line (on top of regular line)
   glBegin(GL_LINE_STRIP);
   glVertex2d(llCorner.mX, llCorner.mY);
   glVertex2d(urCorner.mX, urCorner.mY);
   glEnd();

   // Reset GL options
   glDisable(GL_BLEND);
   glDisable(GL_TEXTURE_2D);
   glDisable(GL_LINE_SMOOTH);
   glDisable(GL_LINE_STIPPLE);
   glLineWidth(1);
}