Removed ControlNetFile include from ControlPoint. (1dad2462) · Commits · aflab / astrogeology / ISIS3

isis/src/control/objs/ControlPoint/ControlPoint.cpp

+64 −327

Original line number	Diff line number	Diff line
		@@ -17,9 +17,6 @@
		#include "ControlMeasure.h"
		#include "ControlMeasureLogData.h"
		#include "ControlNet.h"
		#include "ControlNetFile.h"
		#include "ControlNetFile.h"
		#include "ControlNetFileV0002.pb.h"
		#include "Cube.h"
		#include "IString.h"
		#include "Latitude.h"
		@@ -110,209 +107,6 @@ namespace Isis {
		}


		/**
		* This is used when reading from a protocol buffer. Given a file
		* representation (protocol buffer), and log data,
		* construct the control point.
		*
		* @history 2008-06-18 Debbie A. Cook, Swapped Init with SetRadii
		* calls to avoid resetting the surface points with no radii
		* @history 2015-11-03 Kris Becker - invalid flag was not being initialized
		*/
		ControlPoint::ControlPoint(const ControlPointFileEntryV0002 &fileEntry,
		const Distance &majorRad, const Distance &minorRad,
		const Distance &polarRad) : invalid(false) {
		measures = NULL;
		cubeSerials = NULL;
		referenceMeasure = NULL;
		numberOfRejectedMeasures = 0;
		measures = new QHash< QString, ControlMeasure * >;
		cubeSerials = new QStringList;

		id = fileEntry.id().c_str();
		dateTime = "";
		aprioriSurfacePointSource = SurfacePointSource::None;
		aprioriRadiusSource = RadiusSource::None;

		chooserName = fileEntry.choosername().c_str();
		dateTime = fileEntry.datetime().c_str();
		editLock = false;

		parentNetwork = NULL;

		switch (fileEntry.type()) {
		case ControlPointFileEntryV0002_PointType_obsolete_Tie:
		case ControlPointFileEntryV0002_PointType_Free:
		type = Free;
		break;
		case ControlPointFileEntryV0002_PointType_Constrained:
		type = Constrained;
		break;
		case ControlPointFileEntryV0002_PointType_obsolete_Ground:
		case ControlPointFileEntryV0002_PointType_Fixed:
		type = Fixed;
		break;
		default:
		QString msg = "Point type is invalid.";
		throw IException(IException::Programmer, msg, _FILEINFO_);
		}

		ignore = fileEntry.ignore();
		jigsawRejected = fileEntry.jigsawrejected();

		// Read apriori keywords
		if (fileEntry.has_apriorisurfpointsource()) {
		switch (fileEntry.apriorisurfpointsource()) {
		case ControlPointFileEntryV0002_AprioriSource_None:
		aprioriSurfacePointSource = SurfacePointSource::None;
		break;

		case ControlPointFileEntryV0002_AprioriSource_User:
		aprioriSurfacePointSource = SurfacePointSource::User;
		break;

		case ControlPointFileEntryV0002_AprioriSource_AverageOfMeasures:
		aprioriSurfacePointSource = SurfacePointSource::AverageOfMeasures;
		break;

		case ControlPointFileEntryV0002_AprioriSource_Reference:
		aprioriSurfacePointSource = SurfacePointSource::Reference;
		break;

		case ControlPointFileEntryV0002_AprioriSource_Basemap:
		aprioriSurfacePointSource = SurfacePointSource::Basemap;
		break;

		case ControlPointFileEntryV0002_AprioriSource_BundleSolution:
		aprioriSurfacePointSource = SurfacePointSource::BundleSolution;
		break;

		case ControlPointFileEntryV0002_AprioriSource_Ellipsoid:
		case ControlPointFileEntryV0002_AprioriSource_DEM:
		break;
		}
		}

		if (fileEntry.has_apriorisurfpointsourcefile()) {
		aprioriSurfacePointSourceFile = fileEntry.apriorisurfpointsourcefile().c_str();
		}

		if (fileEntry.has_aprioriradiussource()) {
		switch (fileEntry.aprioriradiussource()) {
		case ControlPointFileEntryV0002_AprioriSource_None:
		aprioriRadiusSource = RadiusSource::None;
		break;
		case ControlPointFileEntryV0002_AprioriSource_User:
		aprioriRadiusSource = RadiusSource::User;
		break;
		case ControlPointFileEntryV0002_AprioriSource_AverageOfMeasures:
		aprioriRadiusSource = RadiusSource::AverageOfMeasures;
		break;
		case ControlPointFileEntryV0002_AprioriSource_Ellipsoid:
		aprioriRadiusSource = RadiusSource::Ellipsoid;
		break;
		case ControlPointFileEntryV0002_AprioriSource_DEM:
		aprioriRadiusSource = RadiusSource::DEM;
		break;
		case ControlPointFileEntryV0002_AprioriSource_BundleSolution:
		aprioriRadiusSource = RadiusSource::BundleSolution;
		break;

		case ControlPointFileEntryV0002_AprioriSource_Reference:
		case ControlPointFileEntryV0002_AprioriSource_Basemap:
		break;
		}
		}

		if (fileEntry.has_aprioriradiussourcefile()) {
		aprioriRadiusSourceFile = fileEntry.aprioriradiussourcefile().c_str();
		}

		constraintStatus.reset();

		if (fileEntry.has_apriorix() && fileEntry.has_aprioriy() &&
		fileEntry.has_aprioriz()) {
		SurfacePoint apriori(
		Displacement(fileEntry.apriorix(), Displacement::Meters),
		Displacement(fileEntry.aprioriy(), Displacement::Meters),
		Displacement(fileEntry.aprioriz(), Displacement::Meters));

		if (fileEntry.aprioricovar_size() > 0) {
		symmetric_matrix<double, upper> covar;
		covar.resize(3);
		covar.clear();
		covar(0, 0) = fileEntry.aprioricovar(0);
		covar(0, 1) = fileEntry.aprioricovar(1);
		covar(0, 2) = fileEntry.aprioricovar(2);
		covar(1, 1) = fileEntry.aprioricovar(3);
		covar(1, 2) = fileEntry.aprioricovar(4);
		covar(2, 2) = fileEntry.aprioricovar(5);
		apriori.SetRectangularMatrix(covar);

		if (Displacement(covar(0, 0), Displacement::Meters).isValid() \|\|
		Displacement(covar(1, 1), Displacement::Meters).isValid()) {
		if (fileEntry.latitudeconstrained())
		constraintStatus.set(LatitudeConstrained);
		if (fileEntry.longitudeconstrained())
		constraintStatus.set(LongitudeConstrained);
		if (fileEntry.radiusconstrained())
		constraintStatus.set(RadiusConstrained);
		}
		else if (Displacement(covar(2, 2), Displacement::Meters).isValid()) {
		if (fileEntry.latitudeconstrained())
		constraintStatus.set(LatitudeConstrained);
		if (fileEntry.radiusconstrained())
		constraintStatus.set(RadiusConstrained);
		}
		}

		aprioriSurfacePoint = apriori;
		}

		if (fileEntry.has_adjustedx() &&
		fileEntry.has_adjustedy() &&
		fileEntry.has_adjustedz()) {
		SurfacePoint adjusted(
		Displacement(fileEntry.adjustedx(), Displacement::Meters),
		Displacement(fileEntry.adjustedy(), Displacement::Meters),
		Displacement(fileEntry.adjustedz(), Displacement::Meters));

		if (fileEntry.adjustedcovar_size() > 0) {
		symmetric_matrix<double, upper> covar;
		covar.resize(3);
		covar.clear();
		covar(0, 0) = fileEntry.adjustedcovar(0);
		covar(0, 1) = fileEntry.adjustedcovar(1);
		covar(0, 2) = fileEntry.adjustedcovar(2);
		covar(1, 1) = fileEntry.adjustedcovar(3);
		covar(1, 2) = fileEntry.adjustedcovar(4);
		covar(2, 2) = fileEntry.adjustedcovar(5);
		adjusted.SetRectangularMatrix(covar);
		}

		adjustedSurfacePoint = adjusted;
		}

		if (majorRad.isValid() && minorRad.isValid() && polarRad.isValid()) {
		aprioriSurfacePoint.SetRadii(majorRad, minorRad, polarRad);
		adjustedSurfacePoint.SetRadii(majorRad, minorRad, polarRad);
		}

		referenceExplicitlySet = false;

		for (int m = 0 ; m < fileEntry.measures_size() ; m++) {
		ControlMeasure *measure = new ControlMeasure(fileEntry.measures(m));
		AddMeasure(measure);
		}

		if (fileEntry.has_referenceindex()) {
		SetRefMeasure((*measures)[cubeSerials->at(fileEntry.referenceindex())]);
		}

		// Set edit lock last
		editLock = fileEntry.editlock();
		}


		/**
		* Construct a control point with given Id
		@@ -2324,144 +2118,87 @@ namespace Isis {
		}


		ControlPointFileEntryV0002 ControlPoint::ToFileEntry() const {
		ControlPointFileEntryV0002 fileEntry;

		fileEntry.set_id(GetId().toLatin1().data());
		switch (GetType()) {
		case ControlPoint::Free:
		fileEntry.set_type(ControlPointFileEntryV0002::Free);
		break;
		case ControlPoint::Constrained:
		fileEntry.set_type(ControlPointFileEntryV0002::Constrained);
		break;
		case ControlPoint::Fixed:
		fileEntry.set_type(ControlPointFileEntryV0002::Fixed);
		break;
		}

		if (!GetChooserName().isEmpty()) {
		fileEntry.set_choosername(GetChooserName().toLatin1().data());
		}
		if (!GetDateTime().isEmpty()) {
		fileEntry.set_datetime(GetDateTime().toLatin1().data());
		}
		if (IsEditLocked())
		fileEntry.set_editlock(true);
		if (IsIgnored())
		fileEntry.set_ignore(true);
		if (IsRejected())
		fileEntry.set_jigsawrejected(true);

		if (referenceMeasure && referenceExplicitlySet) {
		fileEntry.set_referenceindex(IndexOfRefMeasure());
		}

		switch (GetAprioriSurfacePointSource()) {
		case ControlPoint::SurfacePointSource::None:
		break;
		case ControlPoint::SurfacePointSource::User:
		fileEntry.set_apriorisurfpointsource(ControlPointFileEntryV0002_AprioriSource_User);
		break;
		case ControlPoint::SurfacePointSource::AverageOfMeasures:
		fileEntry.set_apriorisurfpointsource(ControlPointFileEntryV0002_AprioriSource_AverageOfMeasures);
		break;
		case ControlPoint::SurfacePointSource::Reference:
		fileEntry.set_apriorisurfpointsource(ControlPointFileEntryV0002_AprioriSource_Reference);
		break;
		case ControlPoint::SurfacePointSource::Basemap:
		fileEntry.set_apriorisurfpointsource(ControlPointFileEntryV0002_AprioriSource_Basemap);
		break;
		case ControlPoint::SurfacePointSource::BundleSolution:
		fileEntry.set_apriorisurfpointsource(ControlPointFileEntryV0002_AprioriSource_BundleSolution);
		break;
		default:
		break;
		}
		if (!GetAprioriSurfacePointSourceFile().isEmpty()) {
		fileEntry.set_apriorisurfpointsourcefile(GetAprioriSurfacePointSourceFile().toLatin1().data());
		}

		switch (GetAprioriRadiusSource()) {
		case ControlPoint::RadiusSource::None:
		//! Returns the apriori covar value associated at the given position.
		double ControlPoint::GetAprioriCovar(int position) const {
		SurfacePoint apriori = GetAprioriSurfacePoint();
		symmetric_matrix< double, upper > covar = apriori.GetRectangularMatrix();
		switch (position) {
		case 0:
		return covar(0, 0);
		break;
		case ControlPoint::RadiusSource::User:
		fileEntry.set_aprioriradiussource(ControlPointFileEntryV0002_AprioriSource_User);
		case 1:
		return covar(0, 1);
		break;
		case ControlPoint::RadiusSource::AverageOfMeasures:
		fileEntry.set_aprioriradiussource(ControlPointFileEntryV0002_AprioriSource_AverageOfMeasures);
		case 2:
		return covar(0, 2);
		break;
		case ControlPoint::RadiusSource::Ellipsoid:
		fileEntry.set_aprioriradiussource(ControlPointFileEntryV0002_AprioriSource_Ellipsoid);
		case 3:
		return covar(1, 1);
		break;
		case ControlPoint::RadiusSource::DEM:
		fileEntry.set_aprioriradiussource(ControlPointFileEntryV0002_AprioriSource_DEM);
		case 4:
		return covar(1, 2);
		break;
		case ControlPoint::RadiusSource::BundleSolution:
		fileEntry.set_aprioriradiussource(ControlPointFileEntryV0002_AprioriSource_BundleSolution);
		case 5:
		return covar(2, 2);
		break;
		default:
		break;
		QString msg = "Invalid position given";
		throw IException(IException::Io, msg, _FILEINFO_);
		}

		if (!GetAprioriRadiusSourceFile().isEmpty()) {
		fileEntry.set_aprioriradiussourcefile(GetAprioriRadiusSourceFile().toLatin1().data());
		}

		if (GetAprioriSurfacePoint().Valid()) {
		//! Returns true if there are apriori surface point covar values.
		bool ControlPoint::HasAprioriCovar() const {
		SurfacePoint apriori = GetAprioriSurfacePoint();
		fileEntry.set_apriorix(apriori.GetX().meters());
		fileEntry.set_aprioriy(apriori.GetY().meters());
		fileEntry.set_aprioriz(apriori.GetZ().meters());

		symmetric_matrix< double, upper > covar = apriori.GetRectangularMatrix();
		// If there are values in any of the covar matrices.
		if (covar(0, 0) != 0. \|\| covar(0, 1) != 0. \|\|
		covar(0, 2) != 0. \|\| covar(1, 1) != 0. \|\|
		covar(1, 2) != 0. \|\| covar(2, 2) != 0.) {
		fileEntry.add_aprioricovar(covar(0, 0));
		fileEntry.add_aprioricovar(covar(0, 1));
		fileEntry.add_aprioricovar(covar(0, 2));
		fileEntry.add_aprioricovar(covar(1, 1));
		fileEntry.add_aprioricovar(covar(1, 2));
		fileEntry.add_aprioricovar(covar(2, 2));
		}
		if (constraintStatus.test(LatitudeConstrained))
		// if (!IsLatitudeConstrained())
		fileEntry.set_latitudeconstrained(true);
		if (constraintStatus.test(LongitudeConstrained))
		// if (!IsLongitudeConstrained())
		fileEntry.set_longitudeconstrained(true);
		if (constraintStatus.test(RadiusConstrained))
		// if (!IsRadiusConstrained())
		fileEntry.set_radiusconstrained(true);
		}


		if (GetAdjustedSurfacePoint().Valid()) {
		SurfacePoint adjusted = GetAdjustedSurfacePoint();
		fileEntry.set_adjustedx(adjusted.GetX().meters());
		fileEntry.set_adjustedy(adjusted.GetY().meters());
		fileEntry.set_adjustedz(adjusted.GetZ().meters());
		return true;
		}
		return false;
		}

		//! Returns true if there are adjusted surface point covar values.
		bool ControlPoint::HasAdjustedCovar() const {
		SurfacePoint adjusted = GetAdjustedSurfacePoint();
		symmetric_matrix< double, upper > covar = adjusted.GetRectangularMatrix();
		// If there are values in any of the covar matrices.
		if (covar(0, 0) != 0. \|\| covar(0, 1) != 0. \|\|
		covar(0, 2) != 0. \|\| covar(1, 1) != 0. \|\|
		covar(1, 2) != 0. \|\| covar(2, 2) != 0.) {
		fileEntry.add_adjustedcovar(covar(0, 0));
		fileEntry.add_adjustedcovar(covar(0, 1));
		fileEntry.add_adjustedcovar(covar(0, 2));
		fileEntry.add_adjustedcovar(covar(1, 1));
		fileEntry.add_adjustedcovar(covar(1, 2));
		fileEntry.add_adjustedcovar(covar(2, 2));
		return true;
		}
		return false;
		}

		// Process all measures in the point
		for (int i = 0; i < cubeSerials->size(); i++) {
		*fileEntry.add_measures() =
		(*measures)[cubeSerials->at(i)]->ToProtocolBuffer();
		//! Returns the adjusted covar value associated at the given position.
		double ControlPoint::GetAdjustedCovar(int position) const {
		SurfacePoint adjusted = GetAdjustedSurfacePoint();
		symmetric_matrix< double, upper > covar = adjusted.GetRectangularMatrix();
		switch (position) {
		case 0:
		return covar(0, 0);
		break;
		case 1:
		return covar(0, 1);
		break;
		case 2:
		return covar(0, 2);
		break;
		case 3:
		return covar(1, 1);
		break;
		case 4:
		return covar(1, 2);
		break;
		case 5:
		return covar(2, 2);
		break;
		default:
		QString msg = "Invalid position given";
		throw IException(IException::Io, msg, _FILEINFO_);
		}

		return fileEntry;
		}
		}