using System;
using HalconDotNet;

namespace HalconTools
{
	/// <summary>
	/// This model data class holds general information about a measure
	/// object. To define more specialized measure data objects the
	/// classes MeasurementEdge and MeasurementPair are derived from this
	/// class to be able to distinguish the measure
	/// types and results for simple edges and for edge pairs. The base
	/// class contains the methods to create measure handles and to create
	/// the display results of a measure action. The derived classes
	/// implement the specialized methods to perform a measure operation
	/// and generate the measure results.
	/// </summary>
	public class Measurement
	{
		/// <summary>HALCON measure object (handle).</summary>
		protected HMeasure    mHandle;

		/// <summary>
		/// Flag to distinguish between a linear and circular measure object.
		/// </summary>
		protected   int       mROIType;

		/// <summary>
		/// Model coordinates obtained from the ROI instance.
		/// This coordinates are the base to calculate the measuring field.
		/// </summary>
		protected   HTuple    mROICoord;

		/// <summary>Reference to the ROI.</summary>
		protected   ROI       mRoi;

		/// <summary>
		/// Auxiliary information about the
		/// measuring field calculated using the ROI coordinates.
		/// </summary>
		protected   HTuple    mMeasROI;

		/// <summary>Iconic object to display measure edge results.</summary>
		protected   HXLDCont  mEdgeXLD;

		/// <summary>Iconic object to display mMeasROI.</summary>
		protected   HRegion   mMeasureRegion;

		/// <summary>
		/// Reference to controller class to obtain information about
		/// the context of the measurement, e.g. image, parameter setups etc.
		/// </summary>
		protected MeasureAssistant mMeasAssist;

		/// <summary>
		/// Creates and initializes a measure object based on information the ROI object
		/// about the ROI.
		/// </summary>
		/// <param name="roi">ROI instance</param>
		/// <param name="mAssist">Reference to controller class</param>
		public Measurement(ROI roi, MeasureAssistant mAssist)
		{
			mRoi = roi;
			mMeasAssist = mAssist;
			mROICoord = mRoi.getModelData();
			mEdgeXLD = new HXLDCont();
			mMeasureRegion = new HRegion();

			if (mRoi is ROICircularArc)
				mROIType = ROI.ROI_TYPE_CIRCLEARC;
			else
				mROIType = ROI.ROI_TYPE_LINE;
		}

		/// <summary>
		/// Triggers an update of the measure object for all 
		/// changes concerning the shape of the ROI or the measurement
		/// parameters.
		/// </summary>
		public void UpdateROI()
		{
			mROICoord = mRoi.getModelData();
			UpdateMeasure();
		}

		/// <summary>
		/// Creates a measure object based on the model data
		/// defined by the ROI instance and the parameters
		/// describing the measure context.
		/// </summary>
		protected void UpdateMeasure()
		{
			double extent, sPhi, radius;

			if (mHandle != null)
				mHandle.Dispose();

			mMeasAssist.exceptionText = "";

			try
			{
				switch (mROIType)
				{
					case ROI.ROI_TYPE_CIRCLEARC:

						radius = mROICoord[2].D;
						sPhi = mROICoord[3].D;
						extent = mROICoord[4].D;


						mMeasROI = GenSurCircle(mROICoord, mMeasAssist.mRoiWidth);
						mHandle = new HMeasure(mROICoord[0].D, mROICoord[1].D, radius,
												sPhi, extent,
												mMeasAssist.mRoiWidth,
												mMeasAssist.mWidth, mMeasAssist.mHeight,
												mMeasAssist.mInterpolation);

						break;
                    case ROI.ROI_TYPE_LINE:

                        mMeasROI = GenSurRect2(mROICoord, mMeasAssist.mRoiWidth);
                        mHandle = new HMeasure(mMeasROI[0].D, mMeasROI[1].D,
                                               mMeasROI[2].D, mMeasROI[3].D, mMeasROI[4].D,
                                               mMeasAssist.mWidth, mMeasAssist.mHeight,
                                               mMeasAssist.mInterpolation);
                        break;
                    //case ROI.ROI_TYPE_LINE:

                    //    mMeasROI = GenSurRect2(mROICoord,mMeasAssist.mRoiHeight, mMeasAssist.mRoiWidth);
                    //    mHandle = new HMeasure(mMeasROI[0].D, mMeasROI[1].D,
                    //                           mMeasROI[2].D, mMeasROI[3].D, mMeasROI[4].D,
                    //                           mMeasAssist.mWidth, mMeasAssist.mHeight,
                    //                           mMeasAssist.mInterpolation);
                        break;
				}
			}
			catch (HOperatorException e)
			{
				mEdgeXLD.Dispose();
				mMeasureRegion.Dispose();
				mMeasAssist.exceptionText = e.Message;
				ClearResultData();
				return;
			}
			UpdateResults();
			UpdateMeasureRegion();
		}

		/// <summary>
		/// Defines the measuring field of a linear ROI.
		/// </summary>
		/// <param name="line">
		/// Model data for a linear interactive ROI
		/// </param>
		/// <param name="width">Half width of (rectangular) measure ROI</param>
		/// <returns>Model data describing a linear measuring field</returns>
		private HTuple GenSurRect2(HTuple line, double width)
		{
			double row1 = line[0];
			double col1 = line[1];
			double row2 = line[2];
			double col2 = line[3];

			double phi     = HMisc.AngleLx(row1, col1, row2, col2);
			double length1 = (HMisc.DistancePp(row1, col1, row2, col2)) / 2.0;
			double length2 = width;
			double rowM    = (row1 + row2) / 2;
			double colM    = (col1 + col2) / 2;

			return new HTuple(new double[] { rowM, colM, phi, length1, length2 });
		}

        private HTuple GenSurRect2(HTuple line,double height, double width)
        {
            double row1 = line[0];
            double col1 = line[1];
            double row2 = line[2];
            double col2 = line[3];

            double phi = HMisc.AngleLx(row1, col1, row2, col2);
            double length1 = height / 2.0;
            double length2 = width;
            double rowM = (row1 + row2) / 2;
            double colM = (col1 + col2) / 2;

            return new HTuple(new double[] { rowM, colM, phi, length1, length2 });
        }

		/// <summary>
		/// Defines the measuring field of a circular ROI.
		/// </summary>
		/// <param name="circle">
		/// Model data for a circular ROI
		/// </param>
		/// <param name="width">Radius (half width) of the circular (ring-shaped) ROI</param>
		/// <returns>Model data describing circular measuring field</returns>
		private HTuple GenSurCircle(HTuple circle, double width)
		{
			double row1   = circle[0];
			double col1   = circle[1];
			double radius = circle[2];
			double startPhi  = circle[3];
			double extent    = circle[4];

			if (radius <= width)
				return new HTuple(new double[] { row1, col1, startPhi, extent, (radius + width), 0.0 });
			else
				return new HTuple(new double[] { row1, col1, startPhi, extent, (radius + width), (radius - width) });
		}

		/// <summary>Releases resources used for this measure object.</summary>
		public void ClearMeasurement()
		{
			if (mHandle != null)
			{
				mHandle.Dispose();
				mEdgeXLD.Dispose();
				mMeasureRegion.Dispose();
			}
		}

		/// <summary>
		/// Creates the iconic object for displaying a measured
		/// edge in a linear ROI.
		/// </summary>
		/// <returns>Contour depicting the measured edge</returns>
		public static HXLDCont DetermineEdgeLine(double row, double col, double phi, double width)
		{
			double row1, row2, col1, col2;

			row1 = row - width * Math.Sin(phi + 0.5 * Math.PI);
			col1 = col + width * Math.Cos(phi + 0.5 * Math.PI);
			row2 = row - width * Math.Sin(phi + 1.5 * Math.PI);
			col2 = col + width * Math.Cos(phi + 1.5 * Math.PI);
			return DetermineLine(row1, col1, row2, col2);
		}

		/// <summary>
		/// Creates the iconic object for displaying a measured
		/// edge from the coordinates of the end points.
		/// </summary>
		/// <returns>Contour depicting the measured edge</returns>
		public static HXLDCont DetermineLine(double row1, double col1, double row2, double col2)
		{
			HXLDCont edge = new HXLDCont();
			HTuple rows, cols;

			rows = new HTuple(new double[] { row1, row2 });
			cols = new HTuple(new double[] { col1, col2 });

			edge.GenContourPolygonXld(rows, cols);
			return edge;
		}

		/// <summary>
		/// Creates the iconic object for displaying a measured
		/// edge in a circular ROI.
		/// </summary>
		/// <returns>Edge contour depicting a measured edge</returns>
		public static HXLDCont DetermineEdgeCircularArc(double row, double col, double center_row, double center_col, double radius, double width)
		{
			double row1, row2, col1, col2;

			row1 = row + (center_row - row) / radius * width;
			col1 = col + (center_col - col) / radius * width;
			row2 = row - (center_row - row) / radius * width;
			col2 = col - (center_col - col) / radius * width;

			return DetermineLine(row1, col1, row2, col2);
		}

		/// <summary>
		/// Creates the iconic object for displaying
		/// the arc between edges of a pair.
		/// </summary>
		/// <returns>Edge contour depicting the arc between edges of a pair</returns>
		public static HXLDCont DeterminePairCircularArc(double row1, double col1, double row2, double col2, double cRow, double cCol, double radius, double width, bool positive)
		{
			HXLDCont arc = new HXLDCont();
			double startPhi, endPhi;

			startPhi = Math.Atan2(cRow - row1, col1 - cCol);
			endPhi = Math.Atan2(cRow - row2, col2 - cCol);

			arc.GenEllipseContourXld(cRow, cCol, 0.0, radius, radius, startPhi, endPhi, (positive ? "positive" : "negative"), 1.5);
			return arc;
		}

		/// <summary>
		/// Creates an iconic object depicting the 
		/// measuring field.
		/// </summary>
		public void UpdateMeasureRegion()
		{

			mMeasureRegion.Dispose();
			mMeasureRegion.GenEmptyObj();

			if (mROIType == ROI.ROI_TYPE_CIRCLEARC)
			{
				double sPhi, extent, innerRad, outerRad;
				HTuple innerR, outerR, innerC, outerC;
				HXLDCont outCont, innerCont, contour;

				outCont = new HXLDCont();
				innerCont = new HXLDCont();

				sPhi = mMeasROI[2].D;
				extent = mMeasROI[3].D;
				outerRad = mMeasROI[4].D;
				innerRad = mMeasROI[5].D;


				innerCont.GenCircleContourXld(mMeasROI[0].D, mMeasROI[1].D, innerRad, sPhi, (sPhi + extent), (extent > 0) ? "positive" : "negative", 1.0);
				outCont.GenCircleContourXld(mMeasROI[0].D, mMeasROI[1].D, outerRad, (sPhi + extent), sPhi, (extent > 0) ? "negative" : "positive", 1.0);

				innerCont.GetContourXld(out innerR, out innerC);
				outCont.GetContourXld(out outerR, out outerC);
				innerR = innerR.TupleConcat(outerR);
				innerC = innerC.TupleConcat(outerC);

				contour = new HXLDCont(innerR, innerC);
				contour = contour.CloseContoursXld();

				mMeasureRegion = contour.GenRegionContourXld("margin");

				contour.Dispose();
				innerCont.Dispose();
				outCont.Dispose();
			}
			else
			{
				mMeasureRegion.GenRectangle2(mMeasROI[0].D, mMeasROI[1].D,
											 mMeasROI[2].D, mMeasROI[3].D,
											 mMeasROI[4].D);
			}
		}

		/// <summary>
		/// If calibration data is available and valid, then rectify 
		/// measure result coordinates, otherwise leave them the same
		/// </summary>
		public void Rectify(HTuple row, HTuple col, out HTuple rowRect, out HTuple colRect)
		{
			double unitScale=0.0;

			if (mMeasAssist.mIsCalibValid)
			{
				switch (mMeasAssist.mUnit)
				{
					case "µm":
						unitScale = 0.000001;
						break;
					case "mm":
						unitScale = 0.001;
						break;
					case "cm":
						unitScale = 0.01;
						break;
					case "m":
						unitScale = 1.0;
						break;
					default:
						break;
				}

				HOperatorSet.ImagePointsToWorldPlane(mMeasAssist.mCamParameter,
													 mMeasAssist.mCamPose,
													 row, col, new HTuple(unitScale),
													 out colRect, out rowRect);
			}
			else
			{
				rowRect = row;
				colRect = col;
			}

		}

		/// <summary>
		/// If calibration data is available and valid, then transform the
		/// distance between measure result edges into world coordinates,
		/// else leave them the same.
		/// </summary>
		public HTuple Distance(HTuple row1, HTuple col1, HTuple row2, HTuple col2, int shift)
		{
			HTuple rows, cols, rowRect, colRect;
			HTuple distance = new HTuple();
			HXLDCont contour;


			if (shift == 0)
			{
				if (mROIType == ROI.ROI_TYPE_CIRCLEARC)
				{
					double cRow, cCol, radius, extent, phi1, phi2, phi, res, length, tmp;

					cRow = mROICoord[0].D;
					cCol = mROICoord[1].D;
					radius = mROICoord[2].D;
					extent = mROICoord[4].D;

					HOperatorSet.TupleGenConst(new HTuple(row1.Length), 0.0, out distance);

					for (int i=0; i < distance.Length; i++)
					{
						phi1 = HMisc.AngleLx(cRow, cCol, row1[i].D, col1[i].D);
						phi2 = HMisc.AngleLx(cRow, cCol, row2[i].D, col2[i].D);

						if (extent < 0)
						{
							tmp = phi1;
							phi1 = phi2;
							phi2 = tmp;
						}

						phi = phi2 - phi1;

						if (phi < 0)
							phi += 2 * Math.PI;

						res = 0.05 * 24.0 / (radius * phi);

						contour = new HXLDCont();
						contour.GenEllipseContourXld(cRow, cCol, 0, radius, radius, phi1, phi2, "positive", res);
						contour.GetContourXld(out rows, out cols);
						Rectify(rows, cols, out rowRect, out colRect);
						contour.Dispose();
						contour.GenContourPolygonXld(rowRect, colRect);
						length = contour.LengthXld();
						distance[i].D = length;
						contour.Dispose();
					}

				}
				else if (mROIType == ROI.ROI_TYPE_LINE)
				{
					HTuple rRect1, cRect1, rRect2, cRect2;
					Rectify(row1, col1, out rRect1, out cRect1);
					Rectify(row2, col2, out rRect2, out cRect2);
					distance = HMisc.DistancePp(rRect1, cRect1, rRect2, cRect2);
				}
				return distance;

			}
			else
			{
				HTuple rClip1, cClip1, rShift2, cShift2;

				rClip1 = row1.TupleSelectRange(new HTuple(0), new HTuple(row1.Length - shift - 1));
				cClip1 = col1.TupleSelectRange(new HTuple(0), new HTuple(col1.Length - shift - 1));
				rShift2 = row2.TupleSelectRange(new HTuple(shift), new HTuple(row2.Length - 1));
				cShift2 = col2.TupleSelectRange(new HTuple(shift), new HTuple(col2.Length - 1));

				return this.Distance(rClip1, cClip1, rShift2, cShift2, 0);
			}
		}

		/// <summary>
		/// Returns the iconic object describing the measuring field
		/// of the measure object.
		/// </summary>
		public HRegion getMeasureRegion()
		{
			return mMeasureRegion;
		}

		/// <summary>
		/// Returns the iconic object depicting the measured edges.
		/// </summary>
		public HXLDCont getMeasureResults()
		{
			return mEdgeXLD;
		}

		/// <summary>
		/// Returns the gray-value profile obtained by the measure projection
		/// operation.
		/// </summary>
		/// <returns>Gray-value profile</returns>
		public double[] getGrayValueProj()
		{
			HTuple grayVal;

			if (mHandle == null || (int)mHandle.Handle < 0)
				return null;

			grayVal = mHandle.MeasureProjection(mMeasAssist.mImage);
			return grayVal.ToDArr();
		}

		/********************************************************/
		/********************************************************/
		/// <summary>
		/// Virtual method to be implemented by the derived classes.
		/// </summary>
		public virtual void UpdateResults() { }
		/// <summary>
		/// Virtual method to be implemented by the derived classes.
		/// </summary>
		public virtual void UpdateXLD() { }
		/// <summary>
		/// Virtual method to be implemented by the derived classes.
		/// </summary>
		public virtual void ClearResultData() { }
		/// <summary>
		/// Virtual method to be implemented by the derived classes.
		/// </summary>
		public virtual MeasureResult getMeasureResultData()
		{
			return null;
		}

	}//end of class
}//end of namespace