rspfAnnotationFontObject::rspfAnnotationFontObject(const rspfIpt& upperLeft, const rspfString& s, const rspfIpt& pixelSize, double rotation, const rspfDpt& scale, const rspfDpt& shear, unsigned char r, unsigned char g, unsigned char b) :rspfAnnotationObject(r,g,b), theFont(rspfFontFactoryRegistry::instance()->getDefaultFont()), theString(s), thePixelSize(pixelSize), theRotation(rotation), theHorizontalScale(scale.x), theVerticalScale(scale.y), theHorizontalShear(shear.x), theVerticalShear(shear.y) { setFontInfo(); thePosition = upperLeft; computeBoundingRect(); #if 0 if (theFont) { theFont->getBoundingBox(theBoundingRect); } theBoundingRect += upperLeft; thePosition = theBoundingRect.ul(); #endif }
void rspfVpfAnnotationSource::setAllFeatures(const std::vector<rspfVpfAnnotationFeatureInfo*>& features) { theFeatureList = features; computeBoundingRect(); }
void ossimGeoAnnotationSource::transformObjects(ossimImageGeometry* geom) { ossimRefPtr<ossimImageGeometry> tempGeom = geom; if(!tempGeom) { tempGeom = m_geometry.get(); } if(!tempGeom) return; AnnotationObjectListType::iterator currentObject; currentObject = theAnnotationObjectList.begin(); while(currentObject != theAnnotationObjectList.end()) { // this is safe since we trapped all adds to make // sure that each object added to the list is // geographic. ossimGeoAnnotationObject* object = static_cast<ossimGeoAnnotationObject*>((*currentObject).get()); // transform the object to image space. object->transform(m_geometry.get()); ++currentObject; } computeBoundingRect(); }
void rspfGeoPolyCutter::transformVertices() { if(!theViewProjection) return; if(theGeoPolygonList.size()) { if(theGeoPolygonList.size() != thePolygonList.size()) { thePolygonList.resize(theGeoPolygonList.size()); } int i = 0; int j = 0; for(i = 0; i < (int)theGeoPolygonList.size(); ++i) { rspfGeoPolygon& gpoly = theGeoPolygonList[i]; rspfPolygon& poly = thePolygonList[i]; int nvert = (int)gpoly.size(); if((int)poly.getVertexCount() != nvert) { poly.resize(nvert); } for(j = 0; j < nvert; ++j) { // rspfDpt error; theViewProjection->worldToLocal(gpoly[j], poly[j]); // theViewProjection->getRoundTripError(rspfIpt(poly[j]), error); // poly[j] = poly[j] + error; poly[j] = rspfDpt(rspf::round<int>(poly[j].x), rspf::round<int>(poly[j].y)); } } computeBoundingRect(); } }
void rspfAnnotationLineObject::setLine(const rspfDpt& start, const rspfDpt& end) { theStart = start; theEnd = end; computeBoundingRect(); }
void CanvasElement::modelChanged() { kDebug() ;//<< id(); m_pen = QPen(Dot2QtConsts::componentData().qtColor(m_element->fontColor())); m_font = FontsCache::changeable().fromName(m_element->fontName()); prepareGeometryChange(); computeBoundingRect(); }
void rspfAnnotationLineObject::applyScale(double x, double y) { theStart.x = rspf::round<int>(theStart.x*x); theStart.y = rspf::round<int>(theStart.y*y); theEnd.x = rspf::round<int>(theEnd.x*x); theEnd.y = rspf::round<int>(theEnd.y*y); computeBoundingRect(); }
void rspfPolyCutter::setPolygon(const vector<rspfIpt>& polygon, rspf_uint32 index) { if(polygon.size()) { thePolygonList[index] = polygon; computeBoundingRect(); } }
void rspfAnnotationFontObject::applyScale(double x, double y) { thePosition.x = rspf::round<int>(thePosition.x *x); thePosition.y = rspf::round<int>(thePosition.y *y); setFontInfo(); computeBoundingRect(); }
// rspfPolyCutter::rspfPolyCutter(rspfImageSource* inputSource, // rspfPolyArea2d* polygon) rspfPolyCutter::rspfPolyCutter(rspfImageSource* inputSource, const rspfPolygon& polygon) : rspfImageSourceFilter(inputSource), theTile(NULL), theCutType(RSPF_POLY_NULL_INSIDE), m_boundingOverwrite(false) { thePolygonList.push_back(polygon); computeBoundingRect(); initialize(); }
ossimAnnotationMultiPolyObject::ossimAnnotationMultiPolyObject(const vector<ossimPolygon>& multiPoly, bool enableFill, unsigned char r, unsigned char g, unsigned char b, long thickness) :ossimAnnotationObject(r, g, b, thickness), theFillEnabled(enableFill) { theMultiPolygon = multiPoly; computeBoundingRect(); }
rspfAnnotationLineObject::rspfAnnotationLineObject(const rspfIpt& start, const rspfIpt& end, unsigned char r, unsigned char g, unsigned char b, long thickness) :rspfAnnotationObject(r, g, b, thickness), theStart(start), theEnd(end) { computeBoundingRect(); }
void rspfGeoAnnotationMultiEllipseObject::transform( rspfImageGeometry* projection) { const std::vector<rspfGpt>::size_type BOUNDS = thePointList.size(); theProjectedObject->resize((rspf_uint32)BOUNDS); for(std::vector<rspfGpt>::size_type i = 0; i < BOUNDS; ++i) { projection->worldToLocal(thePointList[(int)i], (*theProjectedObject)[(int)i]); } computeBoundingRect(); }
rspfAnnotationPolyObject::rspfAnnotationPolyObject( const vector<rspfDpt>& imagePts, bool enableFill, rspf_uint8 r, rspf_uint8 g, rspf_uint8 b, rspf_uint8 thickness) :rspfAnnotationObject(r, g, b, thickness), theFillEnabled(enableFill) { thePolygon = imagePts; computeBoundingRect(); }
void rspfAnnotationMultiEllipseObject::applyScale(double x, double y) { int i; int upper = (int)thePointList.size(); for(i = 0; i < upper; ++i) { thePointList[i].x *= x; thePointList[i].y *= y; } theWidthHeight.x *= x; theWidthHeight.y *= y; computeBoundingRect(); }
rspfAnnotationLineObject::rspfAnnotationLineObject(long x1, long y1, long x2, long y2, unsigned char r, unsigned char g, unsigned char b, long thickness) :rspfAnnotationObject(r, g, b, thickness), theStart(x1, y1), theEnd(x2, y2) { computeBoundingRect(); }
rspfAnnotationMultiEllipseObject::rspfAnnotationMultiEllipseObject (const std::vector<rspfDpt>& pointList, const rspfDpt& widthHeight, bool enableFill, unsigned char r, unsigned char g, unsigned char b, long thickness) : rspfAnnotationObject(r, g, b, thickness), thePointList(pointList), theWidthHeight(widthHeight), theFillFlag(enableFill) { computeBoundingRect(); }
bool ossimGeoAnnotationSource::addObject(ossimAnnotationObject* anObject) { ossimGeoAnnotationObject *objectToAdd = PTR_CAST(ossimGeoAnnotationObject, anObject); if(objectToAdd) { ossimAnnotationSource::addObject(objectToAdd); if(m_geometry.valid()) { objectToAdd->transform(m_geometry.get()); computeBoundingRect(); } return true; } return false; }
void CanvasElement::initialize(qreal scaleX, qreal scaleY, qreal xMargin, qreal yMargin, qreal gh, qreal wdhcf, qreal hdvcf) { // kDebug(); setFlag(QGraphicsItem::ItemIsMovable, true); setFlag(QGraphicsItem::ItemIsSelectable, true); m_scaleX = scaleX; m_scaleY = scaleY; m_xMargin = xMargin; m_yMargin = yMargin; // m_gh = gh; m_wdhcf = wdhcf; m_hdvcf = hdvcf; setZValue(m_element->z()); computeBoundingRect(); }
bool rspfPolyCutter::loadState(const rspfKeywordlist& kwl, const char* prefix) { const char* numberPolygons = kwl.find(prefix, NUMBER_POLYGONS_KW); rspfString newPrefix; if(numberPolygons) { thePolygonList.clear(); int npolys = rspfString(numberPolygons).toLong(); for(int i = 0; i < npolys;++i) { thePolygonList.push_back(rspfPolygon()); newPrefix = rspfString(prefix) + "polygon" + rspfString::toString(i)+"."; thePolygonList[i].loadState(kwl, newPrefix.c_str()); } } const char* lookup = kwl.find(prefix, "cut_type"); if(lookup) { theCutType = RSPF_POLY_NULL_INSIDE; rspfString test = lookup; if(test == "null_outside") { theCutType = RSPF_POLY_NULL_OUTSIDE; } } else { theCutType = RSPF_POLY_NULL_OUTSIDE; } computeBoundingRect(); return rspfImageSourceFilter::loadState(kwl, prefix); }
void rspfVpfAnnotationSource::transformObjects(rspfImageGeometry* geom) { if(traceDebug()) { rspfNotify(rspfNotifyLevel_DEBUG) << "rspfVpfAnnotationSource::transformObjects DEBUG: entered..." << std::endl; } rspfImageGeometry* tempGeom = geom; if(!tempGeom) { tempGeom = m_geometry.get(); } if(!tempGeom) return; for(int idx = 0; idx < (int)theLibraryInfo.size(); ++idx) { theLibraryInfo[idx]->transform(tempGeom); } computeBoundingRect(); if(traceDebug()) { rspfNotify(rspfNotifyLevel_DEBUG) << "rspfVpfAnnotationSource::transformObjects DEBUG: leaving..." << std::endl; } }
ossimAnnotationMultiPolyObject::ossimAnnotationMultiPolyObject() :ossimAnnotationObject(), theFillEnabled(false) { computeBoundingRect(); }
void rspfAnnotationMultiEllipseObject::setWidthHeight(const rspfDpt& widthHeight) { theWidthHeight = widthHeight; computeBoundingRect(); }
void rspfPolyCutter::addPolygon(const rspfPolygon& polygon) { thePolygonList.push_back(rspfPolygon(polygon)); computeBoundingRect(); }
void rspfAnnotationPolyObject::applyScale(double x, double y) { thePolygon *= rspfDpt(x, y); computeBoundingRect(); }
void ossimGeographicAnnotationGrid::setViewProjectionInformation(ossimMapProjection* projection, const ossimGrect& boundingGroundRect) { static const char* MODULE = "ossimGeographicAnnotationGrid::setViewProjectionInformation"; theViewProjection = projection; // set the ground and then stretch it // to cover which even degree grid we are currently // in. theGroundRect = boundingGroundRect; // find the even degree grid. ossimGrect rect(ossimGpt(90, -180), ossimGpt(-90, 180)); // make sure that it is within the range of the // geographic grid. ossimGrect clipRect = rect.clipToRect(boundingGroundRect); // for easier math we will shift the points so they // are between 0..360Lon and 0..180Lat. This way // we are working with just positive numbers double upperLeftLonShift = clipRect.ul().lond() + 180; double upperLeftLatShift = clipRect.ul().latd() + 90; double lowerRightLonShift = clipRect.lr().lond() + 180; double lowerRightLatShift = clipRect.lr().latd() + 90; // now find the even boundaries double upperLeftLonCell = floor(upperLeftLonShift/theDeltaLonSpacing)* theDeltaLonSpacing; double upperLeftLatCell = floor(upperLeftLatShift/theDeltaLatSpacing)* theDeltaLatSpacing; double lowerRightLonCell = floor(lowerRightLonShift/theDeltaLonSpacing)* theDeltaLonSpacing; double lowerRightLatCell = floor(lowerRightLatShift/theDeltaLatSpacing)* theDeltaLatSpacing; // now adjust them by 1 boundary distance. upperLeftLonCell -= theDeltaLonSpacing; upperLeftLatCell += theDeltaLatSpacing; lowerRightLonCell += theDeltaLonSpacing; lowerRightLatCell -= theDeltaLatSpacing; // now clamp to the range of the lat and lon upperLeftLonCell = (upperLeftLonCell<0?0:upperLeftLonCell); upperLeftLatCell = (upperLeftLatCell>180?180:upperLeftLatCell); lowerRightLonCell = (lowerRightLonCell>360?360:lowerRightLonCell); lowerRightLatCell = (lowerRightLatCell<0?0:lowerRightLatCell); // now shift them back into range upperLeftLonCell -= 180; upperLeftLatCell -= 90; lowerRightLonCell -= 180; lowerRightLatCell -= 90; const ossimDatum* datum = theGroundRect.ul().datum(); theGroundRect = ossimGrect(upperLeftLatCell, upperLeftLonCell, lowerRightLatCell, lowerRightLonCell, datum); if(traceDebug()) { CLOG << "Ground Rect: " << theGroundRect << endl; } computeBoundingRect(); }