コード例 #1
0
ファイル: RegionCASA.cpp プロジェクト: Astroua/CARTAvis
void RegionCASA::_getWorldVertices(std::vector<casa::Quantity>& x, std::vector<casa::Quantity>& y,
        const casa::CoordinateSystem& csys,
        const casa::Vector<casa::MDirection>& directions ) const {
    const casa::IPosition dirAxes = csys.directionAxesNumbers();
    casa::String xUnit = csys.worldAxisUnits()[dirAxes[0]];
    casa::String yUnit = csys.worldAxisUnits()[dirAxes[1]];
    int directionCount = directions.size();
    x.resize( directionCount );
    y.resize( directionCount );
    for (int i = 0; i < directionCount; i++) {
        x[i] = casa::Quantity(directions[i].getAngle(xUnit).getValue(xUnit)[0], xUnit);
        y[i] = casa::Quantity(directions[i].getAngle(yUnit).getValue(yUnit)[1], yUnit);
    }
}
コード例 #2
0
ファイル: RegionCASA.cpp プロジェクト: Astroua/CARTAvis
std::vector<std::pair<double,double> >
RegionCASA::_getPixelVertices( const casa::AnnotationBase::Direction& corners,
        const casa::CoordinateSystem& csys, const casa::Vector<casa::MDirection>& directions ) const {
    std::vector<casa::Quantity> xx, xy;
    _getWorldVertices(xx, xy, csys, directions );
    casa::Vector<casa::Double> world = csys.referenceValue();
    const casa::IPosition dirAxes = csys.directionAxesNumbers();
    casa::String xUnit = csys.worldAxisUnits()[dirAxes[0]];
    casa::String yUnit = csys.worldAxisUnits()[dirAxes[1]];
    int cornerCount = corners.size();

    std::vector<std::pair<double,double> > pixelVertices( cornerCount );
    for (int i=0; i<cornerCount; i++) {
        world[dirAxes[0]] = xx[i].getValue(xUnit);
        world[dirAxes[1]] = xy[i].getValue(yUnit);
        casa::Vector<casa::Double> pixel;
        csys.toPixel(pixel, world);
        pixelVertices[i]= std::pair<double,double>( pixel[dirAxes[0]], pixel[dirAxes[1]] );
    }
    return pixelVertices;
}
コード例 #3
0
casa::Vector<casa::Double> ImageRegionGenerator::_toWorld( const casa::CoordinateSystem& cSys,
		double x, double y, bool* successful ){
	int pixelCount = cSys.nPixelAxes();
	casa::Vector<casa::Double> pixelPt( pixelCount, 0 );
	casa::Vector<casa::Double> worldPt;
	if ( pixelCount >= 2 ){
		pixelPt[0] = x;
		pixelPt[1] = y;
		try {
			worldPt = cSys.toWorld( pixelPt );
			*successful = true;
		}
		catch( const casa::AipsError& error ){
			qDebug() << error.getMesg().c_str();
			*successful = false;
		}
	}
	else {
		*successful = false;
	}
	return worldPt;
}
コード例 #4
0
ファイル: RegionCASA.cpp プロジェクト: Astroua/CARTAvis
std::vector< std::shared_ptr<Carta::Lib::RegionInfo> >
RegionCASA::_loadRegion( const QString & fname, std::shared_ptr<Carta::Lib::Image::ImageInterface> imagePtr ){
    std::vector<std::shared_ptr<Carta::Lib::RegionInfo> > regionInfos;

    casa::String fileName( fname.toStdString().c_str() );
    CCImageBase * base = dynamic_cast<CCImageBase*>( imagePtr.get() );
    if ( base ){
        Carta::Lib::Image::MetaDataInterface::SharedPtr metaPtr = base->metaData();
        CCMetaDataInterface* metaData = dynamic_cast<CCMetaDataInterface*>(metaPtr.get());
        if ( metaData ){
            std::shared_ptr<casa::CoordinateSystem> cs = metaData->getCoordinateSystem();
            std::vector < int > dimensions = imagePtr->dims();
            int dimCount = dimensions.size();
            casa::IPosition shape(dimCount);
            for ( int i = 0; i < dimCount; i++ ){
                shape[i] = dimensions[i];
            }
            casa::RegionTextList regionList( fileName, *cs.get(), shape );
            casa::Vector<casa::AsciiAnnotationFileLine> aaregions = regionList.getLines();
            int regionCount = aaregions.size();
            for ( int i = 0; i < regionCount; i++ ){
                if ( aaregions[i].getType() != casa::AsciiAnnotationFileLine::ANNOTATION ){
                    continue;
                }
                casa::CountedPtr<const casa::AnnotationBase> ann = aaregions[i].getAnnotationBase();
                std::shared_ptr<Carta::Lib::RegionInfo> rInfo( new Carta::Lib::RegionInfo());

                casa::Vector<casa::MDirection> directions = ann->getConvertedDirections();
                casa::AnnotationBase::Direction points = ann->getDirections();
                std::vector<std::pair<double,double> > corners =
                            _getPixelVertices( points, *cs.get(), directions );
                int annType = ann->getType();
                switch( annType ){
                case casa::AnnotationBase::RECT_BOX : {
                    _addCorners( rInfo, corners );
                    rInfo->setRegionType( Carta::Lib::RegionInfo::RegionType::Polygon );
                }
                break;
                case casa::AnnotationBase::ELLIPSE : {
                    rInfo->setRegionType( Carta::Lib::RegionInfo::RegionType::Ellipse );
                    const casa::AnnEllipse* ellipse = dynamic_cast<const casa::AnnEllipse*>( ann.get() );
                    casa::Int directionIndex = cs->findCoordinate(casa::Coordinate::Type::DIRECTION );

                    casa::MDirection::Types csType = casa::MDirection::EXTRA;
                    if ( directionIndex >= 0 ){
                        casa::DirectionCoordinate  dCoord = cs->directionCoordinate(directionIndex);
                        csType = dCoord.directionType();
                    }

                    if ( csType == casa::MDirection::EXTRA ){
                        qWarning( "Unable to complete elliptical region, unspecified direction type.");
                        continue;
                    }

                    // convert to the viewer's world coordinates... <mdirection>
                    casa::MDirection dir_center = casa::MDirection::Convert(ellipse->getCenter( ), csType)();
                    casa::Vector<double> center = dir_center.getAngle("rad").getValue( );
                    // 90 deg around 0 & 180 deg
                    const double major_radius = ellipse->getSemiMajorAxis().getValue("rad");
                    const double minor_radius = ellipse->getSemiMinorAxis().getValue("rad");
                    const double pos_angle = ellipse->getPositionAngle( ).getValue("deg");
                    const bool x_is_major = ((pos_angle > 45.0 && pos_angle < 135.0) ||
                            (pos_angle > 225.0 && pos_angle < 315.0));
                    const double xradius = (x_is_major ? major_radius : minor_radius);
                    const double yradius = (x_is_major ? minor_radius : major_radius);

                    casa::Vector<casa::Double> world0(2, 0);
                    casa::Vector<casa::Double> world1(2, 0);
                    world0[0] = center[0] - xradius;
                    world0[1] = center[1] - yradius;
                    world1[0] = center[0] + xradius;
                    world1[1] = center[1] + yradius;
                    casa::Vector<casa::Double> pixel0(2, 0);
                    casa::Vector<casa::Double> pixel1(2, 0);
                    std::vector<std::pair<double,double> > ellipseCorners(2);

                    const casa::CoordinateSystem ellipsCoord = ellipse->getCsys();
                    bool firstConvert = ellipsCoord.directionCoordinate().toPixel( pixel0, world0 );
                    bool secondConvert = ellipsCoord.directionCoordinate().toPixel( pixel1, world1 );
                    if ( firstConvert && secondConvert ){
                        ellipseCorners[0] = std::pair<double,double>( pixel0[0], pixel0[1] );
                        ellipseCorners[1] = std::pair<double,double>( pixel1[0], pixel1[1] );
                        _addCorners( rInfo, ellipseCorners );
                    }
                    else {
                        qDebug() << "Problem storing ellipse corners: "<<ellipsCoord.errorMessage().c_str();
                    }
                }
                break;
                case casa::AnnotationBase::POLYGON : {
                    _addCorners( rInfo, corners );
                    rInfo->setRegionType( Carta::Lib::RegionInfo::RegionType::Polygon );
                }
                break;
                //Point????
                case casa::AnnotationBase::SYMBOL : {
                    _addCorners( rInfo, corners );
                    rInfo->setRegionType( Carta::Lib::RegionInfo::RegionType::Polygon );
                }
                break;
                }
                regionInfos.push_back( rInfo );

            }
        }
    }
    return regionInfos;
}
コード例 #5
0
std::pair<casa::Vector<casa::Quantity>,casa::Vector<casa::Quantity> > ImageRegionGenerator::_getEllipsePositionRadii(
		Carta::Lib::Regions::Ellipse* ellipse, const casa::CoordinateSystem &cs ){


	QRectF outlineBox = ellipse->outlineBox();
	QPointF topLeftPt = outlineBox.topLeft();
	QPointF centerPt = outlineBox.center();
	bool validCenter = false;
	casa::Vector<casa::Double> centerWorld = _toWorld( cs, centerPt.x(), centerPt.y(), &validCenter );
	bool validTopLeft = false;
	casa::Vector<casa::Double> topLeft = _toWorld( cs, topLeftPt.x(), topLeftPt.y(), &validTopLeft );

	casa::Vector<casa::Quantum<casa::Double> > qcenter, qtlc;
	casa::Vector<casa::Quantity> radii_(2);

	if ( validCenter && validTopLeft ){
		qcenter.resize(2);
		qtlc.resize(2);

		casa::String units( RAD_UNITS.toStdString().c_str() );

		qcenter[0] = casa::Quantum<casa::Double>(centerWorld[0], units);
		qcenter[1] = casa::Quantum<casa::Double>(centerWorld[1], units);

		qtlc[0] = casa::Quantum<casa::Double>(topLeft[0], units);
		qtlc[1] = casa::Quantum<casa::Double>(topLeft[1], units);

		int directionIndex = cs.directionCoordinateNumber();
		casa::MDirection::Types cccs = casa::MDirection::N_Types;
		if ( directionIndex < 0 ){
			// no direction coordinate was found...
			double c0 = qcenter[0].getValue();
			double lc0 = qtlc[0].getValue();
			double c1 = qcenter[1].getValue();
			double lc1 = qtlc[1].getValue();
			radii_[0] = qAbs( c0 - lc0 );
			radii_[1] = qAbs( c1 - lc1 );
		}
		else {
			cccs = cs.directionCoordinate( directionIndex).directionType( true );
			// a direction coordinate was found...

			casa::Vector<casa::Double> center_rad(2);
			center_rad[0] = qcenter[0].getValue( units );
			center_rad[1] = qcenter[1].getValue( units );
			casa::MDirection mdcenter( casa::Quantum<casa::Vector<casa::Double> > (center_rad,units), cccs  );

			casa::Vector<casa::Double> tlc_rad_x(2);
			tlc_rad_x[0] = qtlc[0].getValue( units);
			tlc_rad_x[1] = qcenter[1].getValue( units );
			casa::MDirection mdtlc_x( casa::Quantum<casa::Vector<casa::Double> >(tlc_rad_x,units),cccs );

			casa::Vector<casa::Double> tlc_rad_y(2);
			tlc_rad_y[0] = qcenter[0].getValue(units);
			tlc_rad_y[1] = qtlc[1].getValue(units);
			casa::MDirection mdtlc_y( casa::Quantum<casa::Vector<casa::Double> >(tlc_rad_y,units),cccs );

			double xdistance = mdcenter.getValue( ).separation(mdtlc_x.getValue( ));
			double ydistance = mdcenter.getValue( ).separation(mdtlc_y.getValue( ));
			radii_[0] = casa::Quantity(xdistance, units);
			radii_[1] = casa::Quantity(ydistance, units);
		}
	}
	return std::make_pair(qcenter,radii_);
}