Deliver/include/hw_header/ImageHeader.h

//ImageHeader.h
#pragma once

#define IMAGE_HEADER_LEN		16384	//16K
#define FRAME_HEADER_LEN		4096	// 4K

#define LEN_2			2
#define LEN_4			4
#define LEN_8			8  //DA
#define LEN_12			12 //IS
#define LEN_16			16 //DS
#define LEN_26			26
#define LEN_32			32
#define LEN_64			64 //LO
#define LEN_1024		1024
//float //FL

//对应结构在ECOM中所占的长度
#define FileHeaderLength									64
#define GeneralImageModuleLength							512
#define ModalityImageModuleLength							512
#define ImagePixelModuleLength								128
#define DisplayShutterModuleLength							256
#define XrayGenerationModuleLength							128
#define XrayGridModuleLength								128
#define XrayCollimatorModuleLength							256
#define XrayFiltrationModuleLength							128
#define ModalityDetectorModuleLength						512
#define XrayDetectorModuleLength							32
#define ModalityPositioningModuleLength						512
#define XrayAcquisitionDoseModuleLength						512
#define XrayTomographyAcquisitionModuleLength				256

//1）	文件头
// FileHeader
#define FileHeaderOffset		0
typedef struct tagFileHeader
{
	char		strVersion[LEN_16];    				//ECOM文件的版本号
	char		strVersionDescription[LEN_16];		//版本描述
	UINT		nFileLength;						//整个文件的大小
	UINT		nFrameNumber;						//图像总帧数
	UINT        nFileType;                          //文件类型

	tagFileHeader()
	{
		ZeroMemory(strVersion, LEN_16);    			
		ZeroMemory(strVersionDescription, LEN_16);	
		nFileLength = 0;							
		nFrameNumber = 0;							
		nFileType = 0; 
	}

	tagFileHeader& operator= (const tagFileHeader& tfh)
	{
		strcpy_s(strVersion, LEN_16, tfh.strVersion);
		strcpy_s(strVersionDescription, LEN_16, tfh.strVersionDescription);
		nFileLength = tfh.nFileLength;							
		nFrameNumber = tfh.nFrameNumber;
		nFileType = tfh.nFileType; 

		return *this;
	}

}FileHeader;

// General Image Module
#define GeneralImageModuleOffset  (FileHeaderOffset+FileHeaderLength)
typedef struct tagGeneralImageModule
{
	char			strInstanceNumber[LEN_12] ;				//(0020,0013)
	char			strPatientOrientation[LEN_16]; 			//(0020,0020)
	char			strContentDate[LEN_8];					//(0008,0023)
	char			strContentTime[LEN_16];					//(0008,0033)
	char			strImageType[LEN_16];					//(0008,0008)
	char			strAcquisitionNumber[LEN_12];			//(0020,0012)
	char			strAcquisitionDate[LEN_8];				//(0008,0022)
	char			strAcquisitionTime[LEN_16];				//(0008,0032)
	char			strAcquisitionDatetime[LEN_26];			//(0008,002A)
	char			strImagesinAcquisition[LEN_12];			// (0020,1002)
	char			strQualityControlImage[LEN_16];			//(0028,0300)   
	char			strBurnedInAnnotation[LEN_16];			//(0028,0301) 
	char			strLossyImageCompression[LEN_16];		// (0028,2110)  
	char			strLossyImageCompressionRatio[LEN_16];	// (0028,2112)
	char			strPresentationLUTShape[LEN_16];		// (2050,0020)

	tagGeneralImageModule()
	{
		ZeroMemory(strInstanceNumber, LEN_12) ;				
		ZeroMemory(strPatientOrientation, LEN_16); 			
		ZeroMemory(strContentDate, LEN_8);					
		ZeroMemory(strContentTime, LEN_16);					
		ZeroMemory(strImageType, LEN_16);					
		ZeroMemory(strAcquisitionNumber, LEN_12);			
		ZeroMemory(strAcquisitionDate, LEN_8);				
		ZeroMemory(strAcquisitionTime, LEN_16);				
		ZeroMemory(strAcquisitionDatetime, LEN_26);			
		ZeroMemory(strImagesinAcquisition, LEN_12);			
		ZeroMemory(strQualityControlImage, LEN_16);			 
		ZeroMemory(strBurnedInAnnotation, LEN_16);			
		ZeroMemory(strLossyImageCompression, LEN_16);		
		ZeroMemory(strLossyImageCompressionRatio, LEN_16);	
		ZeroMemory(strPresentationLUTShape, LEN_16);		
	}

	tagGeneralImageModule& operator=(const tagGeneralImageModule& tgi)
	{
		strcpy_s(strInstanceNumber, LEN_12, tgi.strInstanceNumber) ;				
		strcpy_s(strPatientOrientation, LEN_16, tgi.strPatientOrientation); 			
		strcpy_s(strContentDate, LEN_8, tgi.strContentDate);					
		strcpy_s(strContentTime, LEN_16, tgi.strContentTime);					
		strcpy_s(strImageType, LEN_16, tgi.strImageType);					
		strcpy_s(strAcquisitionNumber, LEN_12, tgi.strAcquisitionNumber);			
		strcpy_s(strAcquisitionDate, LEN_8, tgi.strAcquisitionDate);				
		strcpy_s(strAcquisitionTime, LEN_16, tgi.strAcquisitionTime);				
		strcpy_s(strAcquisitionDatetime, LEN_26, tgi.strAcquisitionDatetime);			
		strcpy_s(strImagesinAcquisition, LEN_12, tgi.strImagesinAcquisition);			
		strcpy_s(strQualityControlImage, LEN_16, tgi.strQualityControlImage);			
		strcpy_s(strBurnedInAnnotation, LEN_16, tgi.strBurnedInAnnotation);			
		strcpy_s(strLossyImageCompression, LEN_16, tgi.strLossyImageCompression);		
		strcpy_s(strLossyImageCompressionRatio, LEN_16, tgi.strLossyImageCompressionRatio);	
		strcpy_s(strPresentationLUTShape, LEN_16, tgi.strPresentationLUTShape);		

		return *this;
	}
}GeneralImageModule;

//Image Pixel Module
#define	ImagePixelModuleOffset  (GeneralImageModuleOffset+GeneralImageModuleLength)
typedef struct tagImagePixelModule
{
	unsigned short	nSamplesperPixel;							//(0028,0002)
	char			strPhotometricInterpretation[LEN_16];		//(0028,0004)
	unsigned short	Rows;										//(0028,0010)
	unsigned short 	Columns;									//(0028,0011)
	unsigned short 	BitsAllocated;								//(0028,0100)
	unsigned short 	BitsStored;									//(0028,0101)
	unsigned short	HighBit;									//(0028,0102)
	unsigned short 	PixelRepresentation;						//(0028,0103)
	unsigned short 	PlanarConfiguration;						//(0028,0006)
	char			strPixelAspectRatio[LEN_12];				//(0028,0034)
	unsigned short 	SmallestImagePixelValue;					//(0028,0106)
	unsigned short 	LargestImagePixelValue;						//(0028,0107)

	tagImagePixelModule()
	{
		nSamplesperPixel = 0;							
		ZeroMemory(strPhotometricInterpretation, LEN_16);		
		Rows = 0;										
		Columns = 0;									
		BitsAllocated = 0;								
		BitsStored = 0;									
		HighBit = 0;									
		PixelRepresentation = 0;						
		PlanarConfiguration = 0xFF;						
		ZeroMemory(strPixelAspectRatio, LEN_12);				
		SmallestImagePixelValue = 0;					
		LargestImagePixelValue = 0;					
	}

	tagImagePixelModule& operator=(const tagImagePixelModule& tip)
	{
		nSamplesperPixel = tip.nSamplesperPixel;							
		strcpy_s(strPhotometricInterpretation, LEN_16, tip.strPhotometricInterpretation);		
		Rows = tip.Rows;										
		Columns = tip.Columns;									
		BitsAllocated = tip.BitsAllocated;								
		BitsStored = tip.BitsStored;									
		HighBit = tip.HighBit;									
		PixelRepresentation = tip.PixelRepresentation;						
		PlanarConfiguration = tip.PlanarConfiguration;						
		strcpy_s(strPixelAspectRatio, LEN_12, tip.strPixelAspectRatio);				
		SmallestImagePixelValue = tip.SmallestImagePixelValue;					
		LargestImagePixelValue = tip.LargestImagePixelValue;					

		return *this;
	}

}ImagePixelModule;

//DX Image Module -- ModalityImageModule	General Image Module基础上加入一下信息：
#define ModalityImageModuleOffset	(ImagePixelModuleOffset+ImagePixelModuleLength)
typedef struct tagModalityImageModule
{
	unsigned short  nPixelRepresentation;							//(0028,0103)
	char			strPixelIntensityRelationship[LEN_16];			//(0028,1040)
	signed	short  nPixelIntensityRelationshipSign;					//(0028,1041)
	char			strRescaleIntercept[LEN_16];					//(0028,1052)
	char			strRescaleSlope[LEN_16];						//(0028,1053)
	char			strRescaleType[LEN_64];							//(0028,1054)
	char			strAcquisitionDeviceProcessingDescription[LEN_64];		//(0018,1400)
	char			strAcquisitionDeviceProcessingCode[LEN_64];		//(0018,1401)
	char			strCalibrationImage[LEN_16];					//(0050,0004)
	char			strWindowCenter[LEN_16];						//(0028,1050)
	char			strWindowWidth[LEN_16];							//(0028,1051)

	tagModalityImageModule()
	{
		nPixelRepresentation = 0;							
		ZeroMemory(strPixelIntensityRelationship, LEN_16);			
		nPixelIntensityRelationshipSign = 0;					
		ZeroMemory(strRescaleIntercept, LEN_16);					
		ZeroMemory(strRescaleSlope, LEN_16);						
		ZeroMemory(strRescaleType, LEN_64);							
		ZeroMemory(strAcquisitionDeviceProcessingDescription, LEN_64);		
		ZeroMemory(strAcquisitionDeviceProcessingCode, LEN_64);		
		ZeroMemory(strCalibrationImage, LEN_16);					
		ZeroMemory(strWindowCenter, LEN_16);						
		ZeroMemory(strWindowWidth, LEN_16);							
	}

	tagModalityImageModule& operator=(const tagModalityImageModule& tmi)
	{
		nPixelRepresentation = tmi.nPixelRepresentation;							
		strcpy_s(strPixelIntensityRelationship, LEN_16, tmi.strPixelIntensityRelationship);			
		nPixelIntensityRelationshipSign = tmi.nPixelIntensityRelationshipSign;					
		strcpy_s(strRescaleIntercept, LEN_16, tmi.strRescaleIntercept);					
		strcpy_s(strRescaleSlope, LEN_16, tmi.strRescaleSlope);						
		strcpy_s(strRescaleType, LEN_64, tmi.strRescaleType);							
		strcpy_s(strAcquisitionDeviceProcessingDescription, LEN_64, tmi.strAcquisitionDeviceProcessingDescription);		
		strcpy_s(strAcquisitionDeviceProcessingCode, LEN_64, tmi.strAcquisitionDeviceProcessingCode);		
		strcpy_s(strCalibrationImage, LEN_16, tmi.strCalibrationImage);					
		strcpy_s(strWindowCenter, LEN_16, tmi.strWindowCenter);						
		strcpy_s(strWindowWidth, LEN_16, tmi.strWindowWidth);		

		return *this;
	}

}ModalityImageModule;


//Display Shutter Module
#define DisplayShutterModuleOffset	(ModalityImageModuleOffset+ModalityImageModuleLength)
typedef struct tagDisplayShutterModule
{
	char			strShutterShape[LEN_16];					//(0018,1600)
	char			strShutterLeftVerticalEdge[LEN_12];			//(0018,1602)
	char			strShutterRightVerticalEdge[LEN_12];		//(0018,1604)
	char			strShutterUpperHorizontalEdge[LEN_12];		//(0018,1606)
	char			strShutterLowerHorizontalEdge[LEN_12];		//(0018,1608)
	char			strCenterofCircularShutter[LEN_12];			//(0018,1610)
	char			strRadiusofCircularShutter[LEN_12];			//(0018,1612)
	char			strVerticesofthePolygonalShutter[LEN_12];	//(0018,1620)
	unsigned short  nShutterPresentationValue;					//(0018,1622)

	tagDisplayShutterModule()
	{
		ZeroMemory(strShutterShape, LEN_16);				
		ZeroMemory(strShutterLeftVerticalEdge, LEN_12);		
		ZeroMemory(strShutterRightVerticalEdge, LEN_12);		
		ZeroMemory(strShutterUpperHorizontalEdge, LEN_12);	
		ZeroMemory(strShutterLowerHorizontalEdge, LEN_12);	
		ZeroMemory(strCenterofCircularShutter, LEN_12);		
		ZeroMemory(strRadiusofCircularShutter, LEN_12);		
		ZeroMemory(strVerticesofthePolygonalShutter, LEN_12);	
		nShutterPresentationValue = 0xFF;			
	}

	tagDisplayShutterModule& operator=(const tagDisplayShutterModule& tds)
	{
		strcpy_s(strShutterShape, LEN_16, tds.strShutterShape);				
		strcpy_s(strShutterLeftVerticalEdge, LEN_12, tds.strShutterLeftVerticalEdge);		
		strcpy_s(strShutterRightVerticalEdge, LEN_12, tds.strShutterRightVerticalEdge);		
		strcpy_s(strShutterUpperHorizontalEdge, LEN_12, tds.strShutterUpperHorizontalEdge);	
		strcpy_s(strShutterLowerHorizontalEdge, LEN_12, tds.strShutterLowerHorizontalEdge);	
		strcpy_s(strCenterofCircularShutter, LEN_12, tds.strCenterofCircularShutter);		
		strcpy_s(strRadiusofCircularShutter, LEN_12, tds.strRadiusofCircularShutter);		
		strcpy_s(strVerticesofthePolygonalShutter, LEN_12, tds.strVerticesofthePolygonalShutter);	
		nShutterPresentationValue = tds.nShutterPresentationValue;		

		return *this;
	}
}DisplayShutterModule;

//X-RAY GENERATION MODULE
#define XrayGenerationModuleOffset	(DisplayShutterModuleOffset+DisplayShutterModuleLength)
typedef struct tagXrayGenerationModule
{
	char			strExposureControlMode[LEN_16];			//(0018,7060) 
	char			strExposureStatus[LEN_16];				//(0018,7064) 
	char			strPhototimerSetting[LEN_16];			//(0018,7065)
	char			strFocalSpot[LEN_16];					//(0018,1190)

	tagXrayGenerationModule()
	{
		ZeroMemory(strExposureControlMode, LEN_16);			
		ZeroMemory(strExposureStatus, LEN_16);					
		ZeroMemory(strPhototimerSetting, LEN_16);			
		ZeroMemory(strFocalSpot, LEN_16);					
	}

	tagXrayGenerationModule& operator=(const tagXrayGenerationModule& txg)
	{
		strcpy_s(strExposureControlMode, LEN_16, txg.strExposureControlMode);			
		strcpy_s(strExposureStatus, LEN_16, txg.strExposureStatus);					
		strcpy_s(strPhototimerSetting, LEN_16, txg.strPhototimerSetting);			
		strcpy_s(strFocalSpot, LEN_16, txg.strFocalSpot);	

		return *this;
	}
}XrayGenerationModule;

//X-Ray Grid Module
#define XrayGridModuleOffset	(XrayGenerationModuleOffset+XrayGenerationModuleLength)
typedef struct tagXrayGridModule
{
	char		strGrid[LEN_16];							//(0018,1166) 
	char		strGridThickness[LEN_16];					//(0018,7042)
	char		strGridPitch[LEN_16];						//(0018,7044)
	char		strGridAspectRatio[LEN_12];					//(0018,7046)
	char 		strGridPeriod[LEN_16];						//(0018,7048)
	char		strGridFocalDistance[LEN_16];				//(0018,704C)

	tagXrayGridModule()
	{
		ZeroMemory(strGrid, LEN_16);							
		ZeroMemory(strGridThickness, LEN_16);					
		ZeroMemory(strGridPitch, LEN_16);						
		ZeroMemory(strGridAspectRatio, LEN_12);				
		ZeroMemory(strGridPeriod, LEN_16);				
		ZeroMemory(strGridFocalDistance, LEN_16);			
	}

	tagXrayGridModule& operator=(const tagXrayGridModule& txg)
	{
		strcpy_s(strGrid, LEN_16, txg.strGrid);							
		strcpy_s(strGridThickness, LEN_16, txg.strGridThickness);					
		strcpy_s(strGridPitch, LEN_16, txg.strGridPitch);						
		strcpy_s(strGridAspectRatio, LEN_12, txg.strGridAspectRatio);				
		strcpy_s(strGridPeriod, LEN_16, txg.strGridPeriod);				
		strcpy_s(strGridFocalDistance, LEN_16, txg.strGridFocalDistance);	
		return *this;
	}
}XrayGridModule;

//X-Ray Collimator attributes
#define XrayCollimatorModuleOffset	(XrayGridModuleOffset+XrayGridModuleLength)
typedef struct tagXrayCollimatorModule
{
	char			strCollimatorShape[LEN_16];						//(0018,1700)
	char			strCollimatorLeftVerticalEdge[LEN_12];			//(0018,1702)
	char			strCollimatorRightVerticalEdge[LEN_12];			//(0018,1704)
	char			strCollimatorUpperHorizontalEdge[LEN_12];		//(0018,1706)
	char			strCollimatorLowerHorizontalEdge[LEN_12];		//(0018,1708)
	char			strCenterofCircularCollimator[LEN_12];			//(0018,1710)
	char			strRadiusofCircularCollimator[LEN_12];			//(0018,1712)
	char			strVerticesofthePolygonalCollimator[LEN_12];	//(0018,1720)

	tagXrayCollimatorModule()
	{
		ZeroMemory(strCollimatorShape, LEN_16);						
		ZeroMemory(strCollimatorLeftVerticalEdge, LEN_12);			
		ZeroMemory(strCollimatorRightVerticalEdge, LEN_12);			
		ZeroMemory(strCollimatorUpperHorizontalEdge, LEN_12);		
		ZeroMemory(strCollimatorLowerHorizontalEdge, LEN_12);		
		ZeroMemory(strCenterofCircularCollimator, LEN_12);			
		ZeroMemory(strRadiusofCircularCollimator, LEN_12);			
		ZeroMemory(strVerticesofthePolygonalCollimator, LEN_12);	
	}

	tagXrayCollimatorModule& operator=(const tagXrayCollimatorModule& txc)
	{
		strcpy_s(strCollimatorShape, LEN_16, txc.strCollimatorShape);						
		strcpy_s(strCollimatorLeftVerticalEdge, LEN_12, txc.strCollimatorLeftVerticalEdge);			
		strcpy_s(strCollimatorRightVerticalEdge, LEN_12, txc.strCollimatorRightVerticalEdge);			
		strcpy_s(strCollimatorUpperHorizontalEdge, LEN_12, txc.strCollimatorUpperHorizontalEdge);		
		strcpy_s(strCollimatorLowerHorizontalEdge, LEN_12, txc.strCollimatorLowerHorizontalEdge);		
		strcpy_s(strCenterofCircularCollimator, LEN_12, txc.strCenterofCircularCollimator);			
		strcpy_s(strRadiusofCircularCollimator, LEN_12, txc.strRadiusofCircularCollimator);			
		strcpy_s(strVerticesofthePolygonalCollimator, LEN_12, txc.strVerticesofthePolygonalCollimator);	

		return *this;
	}
}XrayCollimatorModule;

//X-Ray Filtration Module
#define XrayFiltrationModuleOffset	(XrayCollimatorModuleOffset+XrayCollimatorModuleLength)
typedef struct tagXrayFiltrationModule
{
	char 		strFilterType[LEN_16];						//(0018,1160)
	char 		strFilterMaterial[LEN_16];					//(0018,7050)
	char		strFilterThicknessMinimum[LEN_16];			//(0018,7052)
	char		strFilterThicknessMaximum[LEN_16];			//(0018,7054)

	tagXrayFiltrationModule()
	{
		ZeroMemory(strFilterType, LEN_16);						
		ZeroMemory(strFilterMaterial, LEN_16);					
		ZeroMemory(strFilterThicknessMinimum, LEN_16);			
		ZeroMemory(strFilterThicknessMaximum, LEN_16);			
	}

	tagXrayFiltrationModule& operator=(const tagXrayFiltrationModule& txf)
	{
		strcpy_s(strFilterType, LEN_16, txf.strFilterType);						
		strcpy_s(strFilterMaterial, LEN_16, txf.strFilterMaterial);					
		strcpy_s(strFilterThicknessMinimum, LEN_16, txf.strFilterThicknessMinimum);			
		strcpy_s(strFilterThicknessMaximum, LEN_16, txf.strFilterThicknessMaximum);	

		return *this;
	}
}XrayFiltrationModule;

//DX Detector Module - ModalityDetectorModule
#define ModalityDetectorModuleOffset	(XrayFiltrationModuleOffset+XrayFiltrationModuleLength)
typedef struct tagModalityDetectorModule
{
	char			strDetectorActiveTime[LEN_16];							//(0018,7014)	
	char			strDetectorActivationOffsetFromExposure[LEN_16];		//(0018,7016)
	char			strFieldofViewShape[LEN_16];							//(0018,1147)
	char			strFieldofViewDimension[LEN_12];						//(0018,1149)
	char			strFieldofViewOrigin[LEN_16];							//(0018,7030)
	char			strFieldofViewRotation[LEN_16];							//(0018,7032) -- 0, 90, 180, 270
	char			strFieldofViewHorizontalFlip[LEN_16];					//(0018,7034) 
	char			strImagerPixelSpacing[LEN_16];							//(0018,1164)
	char			strDetectorType[LEN_16];								//(0018,7004)
	char			strDetectorConfiguration[LEN_16];						//(0018,7005) – AREA, SLOT
	char			strDetectorID[LEN_16];									//(0018,700A)
	char			strDateofLastDetectorCalibration[LEN_8];				//(0018,700C)
	char			strTimeofLastDetectorCalibration[LEN_16];				//(0018,700E)
	char			strExposuresonDetectorSinceLastCalibration[LEN_12];		//(0018,7010)
	char			strExposuresonDetectorSinceManufactured[LEN_12];		//(0018,7011)
	char			strDetectorTimeSinceLastExposure[LEN_16];				//(0018,7012)
	char			strDetectorBinning[LEN_16];								//(0018,701A)
	char			strDetectorConditionsNominalFlag[LEN_16];				//(0018,7000)
	char			strDetectorTemperature[LEN_16];							//(0018,7001)
	char			strSensitivity[LEN_16];									//(0018,6000)
	char			strDetectorElementPhysicalSize[LEN_16];					//(0018,7020)
	char			strDetectorElementSpacing[LEN_16];						//(0018,7022)
	char			strDetectorActiveShape[LEN_16];							//(0018,7024)
	char			strDetectorActiveDimension[LEN_16];						//(0018,7026)
	char			strDetectorActiveOrigin[LEN_16];						//(0018,7028)

	tagModalityDetectorModule()
	{
		ZeroMemory(strDetectorActiveTime, LEN_16);							
		ZeroMemory(strDetectorActivationOffsetFromExposure, LEN_16);		
		ZeroMemory(strFieldofViewShape, LEN_16);							
		ZeroMemory(strFieldofViewDimension, LEN_12);						
		ZeroMemory(strFieldofViewOrigin, LEN_16);							
		ZeroMemory(strFieldofViewRotation, LEN_16);							
		ZeroMemory(strFieldofViewHorizontalFlip, LEN_16);					
		ZeroMemory(strImagerPixelSpacing, LEN_16);							
		ZeroMemory(strDetectorType, LEN_16);								
		ZeroMemory(strDetectorConfiguration, LEN_16);						
		ZeroMemory(strDetectorID, LEN_16);									
		ZeroMemory(strDateofLastDetectorCalibration, LEN_8);				
		ZeroMemory(strTimeofLastDetectorCalibration, LEN_16);				
		ZeroMemory(strExposuresonDetectorSinceLastCalibration, LEN_12);		
		ZeroMemory(strExposuresonDetectorSinceManufactured, LEN_12);		
		ZeroMemory(strDetectorTimeSinceLastExposure, LEN_16);				
		ZeroMemory(strDetectorBinning, LEN_16);								
		ZeroMemory(strDetectorConditionsNominalFlag, LEN_16);				
		ZeroMemory(strDetectorTemperature, LEN_16);							
		ZeroMemory(strSensitivity, LEN_16);									
		ZeroMemory(strDetectorElementPhysicalSize, LEN_16);					
		ZeroMemory(strDetectorElementSpacing, LEN_16);						
		ZeroMemory(strDetectorActiveShape, LEN_16);							
		ZeroMemory(strDetectorActiveDimension, LEN_16);						
		ZeroMemory(strDetectorActiveOrigin, LEN_16);						
	}
	tagModalityDetectorModule& operator=(const tagModalityDetectorModule& tmd)
	{
		strcpy_s(strDetectorActiveTime, LEN_16, tmd.strDetectorActiveTime);							
		strcpy_s(strDetectorActivationOffsetFromExposure, LEN_16, tmd.strDetectorActivationOffsetFromExposure);		
		strcpy_s(strFieldofViewShape, LEN_16, tmd.strFieldofViewShape);							
		strcpy_s(strFieldofViewDimension, LEN_12, tmd.strFieldofViewDimension);						
		strcpy_s(strFieldofViewOrigin, LEN_16, tmd.strFieldofViewOrigin);							
		strcpy_s(strFieldofViewRotation, LEN_16, tmd.strFieldofViewRotation);							
		strcpy_s(strFieldofViewHorizontalFlip, LEN_16, tmd.strFieldofViewHorizontalFlip);					
		strcpy_s(strImagerPixelSpacing, LEN_16, tmd.strImagerPixelSpacing);							
		strcpy_s(strDetectorType, LEN_16, tmd.strDetectorType);								
		strcpy_s(strDetectorConfiguration, LEN_16, tmd.strDetectorConfiguration);						
		strcpy_s(strDetectorID, LEN_16, tmd.strDetectorID);									
		strcpy_s(strDateofLastDetectorCalibration, LEN_8, tmd.strDateofLastDetectorCalibration);				
		strcpy_s(strTimeofLastDetectorCalibration, LEN_16, tmd.strTimeofLastDetectorCalibration);				
		strcpy_s(strExposuresonDetectorSinceLastCalibration, LEN_12, tmd.strExposuresonDetectorSinceLastCalibration);		
		strcpy_s(strExposuresonDetectorSinceManufactured, LEN_12, tmd.strExposuresonDetectorSinceManufactured);		
		strcpy_s(strDetectorTimeSinceLastExposure, LEN_16, tmd.strDetectorTimeSinceLastExposure);				
		strcpy_s(strDetectorBinning, LEN_16, tmd.strDetectorBinning);								
		strcpy_s(strDetectorConditionsNominalFlag, LEN_16, tmd.strDetectorConditionsNominalFlag);				
		strcpy_s(strDetectorTemperature, LEN_16, tmd.strDetectorTemperature);							
		strcpy_s(strSensitivity, LEN_16, tmd.strSensitivity);									
		strcpy_s(strDetectorElementPhysicalSize, LEN_16, tmd.strDetectorElementPhysicalSize);					
		strcpy_s(strDetectorElementSpacing, LEN_16, tmd.strDetectorElementSpacing);						
		strcpy_s(strDetectorActiveShape, LEN_16, tmd.strDetectorActiveShape);							
		strcpy_s(strDetectorActiveDimension, LEN_16, tmd.strDetectorActiveDimension);						
		strcpy_s(strDetectorActiveOrigin, LEN_16, tmd.strDetectorActiveOrigin);	
		return *this;
	}
}ModalityDetectorModule;

//X-Ray Detector Module
#define XrayDetectorModuleOffset	(ModalityDetectorModuleOffset+ModalityDetectorModuleLength)
typedef struct tagXrayDetectorModule
{
	float			fPhysicalDetectorSize;						//(0018,9429)
	float			fPositionofIsocenterProjection;				//(0018,9430)

	tagXrayDetectorModule()
	{
		fPhysicalDetectorSize = 0;
		fPositionofIsocenterProjection = 0;
	}

	tagXrayDetectorModule& operator=(const tagXrayDetectorModule& txd)
	{
		fPhysicalDetectorSize = txd.fPhysicalDetectorSize;
		fPositionofIsocenterProjection = txd.fPositionofIsocenterProjection;

		return *this;
	}
}XrayDetectorModule;

//DX Positioning Module - ModalityPositioningModule
#define ModalityPositioningModuleOffset	(XrayDetectorModuleOffset+XrayDetectorModuleLength)
typedef struct tagModalityPositioningModule
{
	char  			strPatientPosition[LEN_16];					//(0018,5100)
	char			strViewPosition[LEN_16];					//(0018,5101)
	char			strDistanceSourcetoPatient[LEN_16];			//(0018,1111)
	char			strDistanceSourcetoDetector[LEN_16];			//(0018,1110)
	char			strEstimatedRadiographicMagnificationFactor[LEN_16];		//(0018,1114)
	char			strPositionerType[LEN_16];					//(0018,1508)
	char			strPositionerPrimaryAngle[LEN_16];			//(0018,1510)
	char			strPositionerSecondaryAngle[LEN_16];			//(0018,1511)
	char			strDetectorPrimaryAngle[LEN_16];			//(0018,1530)
	char			strDetectorSecondaryAngle[LEN_16];			//(0018,1531)
	char			strColumnAngulation[LEN_16];				//(0018,1450)
	char			strTableType[LEN_16];						//(0018,113A)
	char			strTableAngle[LEN_16];						//(0018,1138)
	char			strBodyPartThickness[LEN_16];				//(0018,11A0)
	char			strCompressionForce[LEN_16];				//(0018,11A2)
	char			strOrganExposed[LEN_16];					//(0040,0318)
	char			strBreastImplantPresent[LEN_16];			//(0028,1300)

	tagModalityPositioningModule()
	{
		ZeroMemory(strPatientPosition, LEN_16);					
		ZeroMemory(strViewPosition, LEN_16);					
		ZeroMemory(strDistanceSourcetoPatient, LEN_16);			
		ZeroMemory(strDistanceSourcetoDetector, LEN_16);			
		ZeroMemory(strEstimatedRadiographicMagnificationFactor, LEN_16);		
		ZeroMemory(strPositionerType, LEN_16);					
		ZeroMemory(strPositionerPrimaryAngle, LEN_16);			
		ZeroMemory(strPositionerSecondaryAngle, LEN_16);			
		ZeroMemory(strDetectorPrimaryAngle, LEN_16);			
		ZeroMemory(strDetectorSecondaryAngle, LEN_16);			
		ZeroMemory(strColumnAngulation, LEN_16);				
		ZeroMemory(strTableType, LEN_16);						
		ZeroMemory(strTableAngle, LEN_16);						
		ZeroMemory(strBodyPartThickness, LEN_16);				
		ZeroMemory(strCompressionForce, LEN_16);				
		ZeroMemory(strOrganExposed, LEN_16);					
		ZeroMemory(strBreastImplantPresent, LEN_16);			
	}

	tagModalityPositioningModule& operator=(const tagModalityPositioningModule& tmp)
	{
		strcpy_s(strPatientPosition, LEN_16, tmp.strPatientPosition);					
		strcpy_s(strViewPosition, LEN_16, tmp.strViewPosition);					
		strcpy_s(strDistanceSourcetoPatient, LEN_16, tmp.strDistanceSourcetoPatient);			
		strcpy_s(strDistanceSourcetoDetector, LEN_16, tmp.strDistanceSourcetoDetector);			
		strcpy_s(strEstimatedRadiographicMagnificationFactor, LEN_16, tmp.strEstimatedRadiographicMagnificationFactor);		
		strcpy_s(strPositionerType, LEN_16, tmp.strPositionerType);					
		strcpy_s(strPositionerPrimaryAngle, LEN_16, tmp.strPositionerPrimaryAngle);			
		strcpy_s(strPositionerSecondaryAngle, LEN_16, tmp.strPositionerSecondaryAngle);			
		strcpy_s(strDetectorPrimaryAngle, LEN_16, tmp.strDetectorPrimaryAngle);			
		strcpy_s(strDetectorSecondaryAngle, LEN_16, tmp.strDetectorSecondaryAngle);			
		strcpy_s(strColumnAngulation, LEN_16, tmp.strColumnAngulation);				
		strcpy_s(strTableType, LEN_16, tmp.strTableType);						
		strcpy_s(strTableAngle, LEN_16, tmp.strTableAngle);						
		strcpy_s(strBodyPartThickness, LEN_16, tmp.strBodyPartThickness);				
		strcpy_s(strCompressionForce, LEN_16, tmp.strCompressionForce);				
		strcpy_s(strOrganExposed, LEN_16, tmp.strOrganExposed);					
		strcpy_s(strBreastImplantPresent, LEN_16, tmp.strBreastImplantPresent);	
		return *this;
	}
}ModalityPositioningModule;

//X-Ray Acquisition Dose Module
#define XrayAcquisitionDoseModuleOffset		(ModalityPositioningModuleOffset+ModalityPositioningModuleLength)
typedef struct tagXrayAcquisitionDoseModule
{
	char			strKVP[LEN_16];							//(0018,0060)
	char			strXRayTubeCurrent[LEN_12];				//(0018,1151)
	char			strXRayTubeCurrentinuA[LEN_16];			//(0018,8151)
	char			strExposureTime[LEN_12];				//(0018,1150)
	char     		strExposureTimeinuS[LEN_16];			//(0018,8150)
	char			strExposure[LEN_12];					//(0018,1152)
	char			strExposureinuAs[LEN_12];				//(0018,1153)
	char			strImageAreaDoseProduct[LEN_16];		//(0018,115E) 
	char			strRelativeXRayExposure[LEN_12];		//(0018,1405)
	unsigned	short  	nEntranceDose;						//(0040,0302)
	char 			strEntranceDoseinmGy[LEN_16];			//(0040,8302)
	unsigned 	short 	nExposedArea;						//(0040,0303)
	char			strDistanceSourcetoEntrance[LEN_16];	//(0040,0306)
	char			strXRayOutput[LEN_16];					//(0040,0312)
	char			strHalfValueLayer[LEN_16];				//(0040,0314)
	char			strOrganDose[LEN_16];					//(0040,0316)
	char 			strAnodeTargetMaterial[LEN_16]; 		//(0018,1191)
	char			strRectificationType[LEN_16];			//(0018,1156)   

	tagXrayAcquisitionDoseModule()
	{
		ZeroMemory(strKVP, LEN_16);							
		ZeroMemory(strXRayTubeCurrent, LEN_12);				
		ZeroMemory(strXRayTubeCurrentinuA, LEN_16);			
		ZeroMemory(strExposureTime, LEN_12);				
		ZeroMemory(strExposureTimeinuS, LEN_16);			
		ZeroMemory(strExposure, LEN_12);					
		ZeroMemory(strExposureinuAs, LEN_12);				
		ZeroMemory(strImageAreaDoseProduct, LEN_16);		
		ZeroMemory(strRelativeXRayExposure, LEN_12);		
		nEntranceDose = 0;						
		ZeroMemory(strEntranceDoseinmGy, LEN_16);			
		nExposedArea = 0;						
		ZeroMemory(strDistanceSourcetoEntrance, LEN_16);	
		ZeroMemory(strXRayOutput, LEN_16);					
		ZeroMemory(strHalfValueLayer, LEN_16);				
		ZeroMemory(strOrganDose, LEN_16);					
		ZeroMemory(strAnodeTargetMaterial, LEN_16); 		
		ZeroMemory(strRectificationType, LEN_16);			
	}

	tagXrayAcquisitionDoseModule& operator=(const tagXrayAcquisitionDoseModule& txa)
	{
		strcpy_s(strKVP, LEN_16, txa.strKVP);							
		strcpy_s(strXRayTubeCurrent, LEN_12, txa.strXRayTubeCurrent);				
		strcpy_s(strXRayTubeCurrentinuA, LEN_16, txa.strXRayTubeCurrentinuA);			
		strcpy_s(strExposureTime, LEN_12, txa.strExposureTime);				
		strcpy_s(strExposureTimeinuS, LEN_16, txa.strExposureTimeinuS);			
		strcpy_s(strExposure, LEN_12, txa.strExposure);					
		strcpy_s(strExposureinuAs, LEN_12, txa.strExposureinuAs);				
		strcpy_s(strImageAreaDoseProduct, LEN_16, txa.strImageAreaDoseProduct);		
		strcpy_s(strRelativeXRayExposure, LEN_12, txa.strRelativeXRayExposure);		
		nEntranceDose = txa.nEntranceDose;						
		strcpy_s(strEntranceDoseinmGy, LEN_16, txa.strEntranceDoseinmGy);			
		nExposedArea = txa.nExposedArea;						
		strcpy_s(strDistanceSourcetoEntrance, LEN_16, txa.strDistanceSourcetoEntrance);	
		strcpy_s(strXRayOutput, LEN_16, txa.strXRayOutput);					
		strcpy_s(strHalfValueLayer, LEN_16, txa.strHalfValueLayer);				
		strcpy_s(strOrganDose, LEN_16, txa.strOrganDose);					
		strcpy_s(strAnodeTargetMaterial, LEN_16, txa.strAnodeTargetMaterial); 		
		strcpy_s(strRectificationType, LEN_16, txa.strRectificationType);		
		return *this;
	}
}XrayAcquisitionDoseModule;

//X-Ray Tomography Acquisition Module
#define XrayTomographyAcquisitionModuleOffset	(XrayAcquisitionDoseModuleOffset+XrayAcquisitionDoseModuleLength)
typedef struct tagXrayTomographyAcquisitionModule
{
	char 			strTomoLayerHeight[LEN_16];					//(0018,1460)
	char			strTomoAngle[LEN_16];						//(0018,1470)
	char			strTomoTime[LEN_16];						//(0018,1480)
	char			strTomoType[LEN_16];						//(0018,1490) 
	char			strTomoClass[LEN_16];						//(0018,1491)
	char			strNumberofTomosynthesis[LEN_12];			//(0018,1495)

	tagXrayTomographyAcquisitionModule()
	{
		ZeroMemory(strTomoLayerHeight, LEN_16);					
		ZeroMemory(strTomoAngle, LEN_16);						
		ZeroMemory(strTomoTime, LEN_16);						
		ZeroMemory(strTomoType, LEN_16);						
		ZeroMemory(strTomoClass, LEN_16);					
		ZeroMemory(strNumberofTomosynthesis, LEN_12);			
	}

	tagXrayTomographyAcquisitionModule& operator=(const tagXrayTomographyAcquisitionModule& txta)
	{
		strcpy_s(strTomoLayerHeight, LEN_16, txta.strTomoLayerHeight);					
		strcpy_s(strTomoAngle, LEN_16, txta.strTomoAngle);						
		strcpy_s(strTomoTime, LEN_16, txta.strTomoTime);						
		strcpy_s(strTomoType, LEN_16, txta.strTomoType);						
		strcpy_s(strTomoClass, LEN_16, txta.strTomoClass);					
		strcpy_s(strNumberofTomosynthesis, LEN_12, txta.strNumberofTomosynthesis);
		return *this;
	}
}XrayTomographyAcquisitionModule;

//Overlay plane module
//UINT		nOffset;
typedef struct tagOverlayplaneModule
{
	unsigned	 short  nOverlayRows;						//(60xx,0010)
	unsigned	 short 	nOverlayColumns;					//(60xx,0011)
	char			strOverlayType[LEN_16];					//(60xx,0040)
	signed short		nOverlayOrigin;						//(60xx,0050)
	unsigned	 short 	nOverlayBitsAllocated;				//(60xx,0100)
	unsigned	 short 	nOverlayBitPosition;				//(60xx,0102)
	char 			strROIArea[LEN_12];						//(60xx,1301)
	char			strROIMean[LEN_16];						//(60xx,1302)
	char			strROIStandardDeviation[LEN_16];		//(60xx,1303)

	tagOverlayplaneModule()
	{
		nOverlayRows = 0;						
		nOverlayColumns = 0;					
		ZeroMemory(strOverlayType, LEN_16);		
		nOverlayOrigin = 0;						
		nOverlayBitsAllocated = 0;			
		nOverlayBitPosition = 0;				
		ZeroMemory(strROIArea, LEN_12);			
		ZeroMemory(strROIMean, LEN_16);			
		ZeroMemory(strROIStandardDeviation, LEN_16);
	}

	tagOverlayplaneModule& operator=(const tagOverlayplaneModule& top)
	{
		nOverlayRows = top.nOverlayRows;						
		nOverlayColumns = top.nOverlayColumns;					
		strcpy_s(strOverlayType, LEN_16, top.strOverlayType);		
		nOverlayOrigin = top.nOverlayOrigin;						
		nOverlayBitsAllocated = top.nOverlayBitsAllocated;
		nOverlayBitPosition = top.nOverlayBitPosition;
		strcpy_s(strROIArea, LEN_12, top.strROIArea);
		strcpy_s(strROIMean, LEN_16, top.strROIMean);
		strcpy_s(strROIStandardDeviation, LEN_16, top.strROIStandardDeviation);
		return *this;
	}
}OverlayplaneModule;

typedef struct tagImageHeader
{
	FileHeader							stFileHeader;
	GeneralImageModule					stGeneralImageModule;
	ImagePixelModule					stImagePixelModule;
	ModalityImageModule					stModalityImageModule;
	DisplayShutterModule				stDisplayShutterModule;
	XrayGenerationModule				stXrayGenerationModule;
	XrayGridModule						stXrayGridModule;
	XrayCollimatorModule				stXrayCollimatorModule;
	XrayFiltrationModule				stXrayFiltrationModule;
	ModalityDetectorModule				stModalityDetectorModule;
	XrayDetectorModule					stXrayDetectorModule;
	ModalityPositioningModule			stModalityPositioningModule;
	XrayAcquisitionDoseModule			stXrayAcquisitionDoseModule;
	XrayTomographyAcquisitionModule		stXrayTomographyAcquisitionModule;

	tagImageHeader& operator=(const tagImageHeader& tih)
	{
		stFileHeader = tih.stFileHeader;
		stGeneralImageModule = tih.stGeneralImageModule;
		stImagePixelModule = tih.stImagePixelModule;
		stModalityImageModule = tih.stModalityImageModule;
		stDisplayShutterModule = tih.stDisplayShutterModule;
		stXrayGenerationModule = tih.stXrayGenerationModule;
		stXrayGridModule = tih.stXrayGridModule;
		stXrayCollimatorModule = tih.stXrayCollimatorModule;
		stXrayFiltrationModule = tih.stXrayFiltrationModule;
		stModalityDetectorModule = tih.stModalityDetectorModule;
		stXrayDetectorModule = tih.stXrayDetectorModule;
		stModalityPositioningModule = tih.stModalityPositioningModule;
		stXrayAcquisitionDoseModule = tih.stXrayAcquisitionDoseModule;
		stXrayTomographyAcquisitionModule = tih.stXrayTomographyAcquisitionModule;

		return *this;
	}

}IMAGE_HEADER;
//===========================================================================================================


#define GenInfoLength									256
#define FpdInfoLength									256
#define TomoInfoLength									256
#define MaskInfoLength									128
#define PositionInfoLength								256
#define CollimatorInfoLength							128

#define FrameHeaderOffset								0

typedef struct tagFrameGenInfo
{
	char	strKVP[LEN_16]; //KV 
	char	strXRayTubeCurrent[LEN_16]; //MA 
	char	strExposureTime[LEN_16]; //MS
	char	strMAS[LEN_16];
	char	strAECDensity[LEN_16];
	char	strAECFilm[LEN_16];
	char	strAECField[LEN_16];
	char	strTechMode[LEN_16];
	char	strFocusSpot[LEN_16]; // Focus

	tagFrameGenInfo()
	{
		ZeroMemory(strKVP, LEN_16);										
		ZeroMemory(strXRayTubeCurrent, LEN_16);						
		ZeroMemory(strExposureTime, LEN_16);			
		ZeroMemory(strMAS, LEN_16);						
		ZeroMemory(strAECDensity, LEN_16);						
		ZeroMemory(strAECFilm, LEN_16);	
		ZeroMemory(strAECField, LEN_16);					
		ZeroMemory(strTechMode, LEN_16);				
		ZeroMemory(strFocusSpot, LEN_16);					

	}

	tagFrameGenInfo& operator=(const tagFrameGenInfo& tgi)
	{
		strcpy_s(strKVP, LEN_16, tgi.strKVP);									
		strcpy_s(strXRayTubeCurrent, LEN_16, tgi.strXRayTubeCurrent);					
		strcpy_s(strExposureTime, LEN_16, tgi.strExposureTime);					
		strcpy_s(strMAS, LEN_16, tgi.strMAS);		
		strcpy_s(strAECDensity, LEN_16, tgi.strAECDensity);				
		strcpy_s(strAECFilm, LEN_16, tgi.strAECFilm);					
		strcpy_s(strAECField, LEN_16, tgi.strAECField);	
		strcpy_s(strTechMode, LEN_16, tgi.strTechMode);					
		strcpy_s(strFocusSpot, LEN_16, tgi.strFocusSpot);				

		return *this;
	}
}FrameGenInfo;

#define FPDInfoOffset FrameHeaderOffset + GenInfoLength //256
typedef struct tagFrameFPDInfo
{
	unsigned short	nImageWidth; // 非DICOM
	unsigned short	nImageHeight; // 非DICOM
	unsigned short	nImageBits; // 非DICOM
	float			fImageCurrentUgy; //DICOM
	float			fImageReferUgy;
	float			fImageDI;
	float			fFPDTemperature;	

	tagFrameFPDInfo()
	{
		nImageWidth = 0;
		nImageHeight = 0;
		nImageBits = 0;
		fImageCurrentUgy = 0.0;			
		fImageReferUgy = 0.0;
		fImageDI = 0.0;
		fFPDTemperature = 0.0;
	}
	tagFrameFPDInfo& operator= (const tagFrameFPDInfo& tfi)
	{//
		nImageWidth		= tfi.nImageWidth;
		nImageHeight	= tfi.nImageHeight;
		nImageBits		= tfi.nImageBits;
		fImageCurrentUgy = tfi.fImageCurrentUgy;			
		fImageReferUgy	= tfi.fImageReferUgy;
		fImageDI		= tfi.fImageDI;
		fFPDTemperature = tfi.fFPDTemperature;	
		return *this;
	}
}FrameFPDInfo;

#define TomoInfoOffset FPDInfoOffset + FpdInfoLength // 512
typedef struct tagFrameTomoInfo
{
	char strTomoAngle[LEN_16];	//在曝光过程中，光源（球馆）扫过的角度 DICOM
	char strTomoTime[LEN_16];	//在曝光过程中，光源（球馆）旋转重用的时间，单位S DICOM


	tagFrameTomoInfo()
	{			
		ZeroMemory(strTomoAngle, LEN_16);						
		ZeroMemory(strTomoTime, LEN_16);							
	}

	tagFrameTomoInfo& operator=(const tagFrameTomoInfo& txta)
	{				
		strcpy_s(strTomoAngle, LEN_16, txta.strTomoAngle);						
		strcpy_s(strTomoTime, LEN_16, txta.strTomoTime);						
		return *this;
	}
}FrameTomoInfo;

#define ImageMaskInfoOffset TomoInfoOffset + TomoInfoLength // 768
#define MASK_NODE_NUM 10
typedef struct tagFrameMaskInfo  //非DICOM
{
	UINT	nNodes; //输入遮光器类型0为矩形，1为原型，2为六边形；

	UINT	nNodeX[MASK_NODE_NUM];  //左上角横坐标;
	UINT	nNodeY[MASK_NODE_NUM];  //左上角纵坐标;


	tagFrameMaskInfo()
	{
		ZeroMemory(this,sizeof(tagFrameMaskInfo));

	}
	tagFrameMaskInfo& operator= (const tagFrameMaskInfo& tmi)
	{//
		memcpy(this,&tmi,sizeof(tagFrameMaskInfo) );
		return *this;
	}
}FrameMaskInfo;

#define PositionInfoOffset ImageMaskInfoOffset + MaskInfoLength //  896
typedef struct tagPositionInfo // DICOM
{
	char strDistanceSourcetoPatient[LEN_16]; //SOD Object
	char strDistanceSourcetoDetector[LEN_16]; //SID Imager

	char strPositionerPrimaryAngle[LEN_16]; //见DICOM
	char strPositionerSecondaryAngle[LEN_16]; //见DICOM
	char strDetectorPrimaryAngle[LEN_16]; //见DICOM
	char strDetectorSecondaryAngle[LEN_16]; //见DICOM

	char strCompressionForce[LEN_16]; //压迫器的压迫力度

	tagPositionInfo()
	{	
		ZeroMemory(strDistanceSourcetoPatient, LEN_16);			
		ZeroMemory(strDistanceSourcetoDetector, LEN_16);			

		ZeroMemory(strPositionerPrimaryAngle, LEN_16);			
		ZeroMemory(strPositionerSecondaryAngle, LEN_16);			
		ZeroMemory(strDetectorPrimaryAngle, LEN_16);			
		ZeroMemory(strDetectorSecondaryAngle, LEN_16);			

		ZeroMemory(strCompressionForce, LEN_16);
	}

	tagPositionInfo& operator=(const tagPositionInfo& tmp)
	{			
		strcpy_s(strDistanceSourcetoPatient, LEN_16, tmp.strDistanceSourcetoPatient);			
		strcpy_s(strDistanceSourcetoDetector, LEN_16, tmp.strDistanceSourcetoDetector);			

		strcpy_s(strPositionerPrimaryAngle, LEN_16, tmp.strPositionerPrimaryAngle);			
		strcpy_s(strPositionerSecondaryAngle, LEN_16, tmp.strPositionerSecondaryAngle);			
		strcpy_s(strDetectorPrimaryAngle, LEN_16, tmp.strDetectorPrimaryAngle);			
		strcpy_s(strDetectorSecondaryAngle, LEN_16, tmp.strDetectorSecondaryAngle);			

		strcpy_s(strCompressionForce, LEN_16, tmp.strCompressionForce);				

		return *this;
	}
}PositionInfo;

#define CollimatorInfoOffset	(PositionInfoOffset + PositionInfoLength)
typedef struct tagCollimatorInfo
{
	UINT			nCollimatorShape;	
	UINT			nCollimatorLeftVerticalEdge;
	UINT			nCollimatorRightVerticalEdge;	
	UINT			nCollimatorUpperHorizontalEdge;	
	UINT			nCollimatorLowerHorizontalEdge;	
	UINT			nCenterofCircularCollimator;
	UINT			nRadiusofCircularCollimator;	 
	UINT			nVerticesofthePolygonalCollimator; 

	tagCollimatorInfo()
	{	
		nCollimatorShape = 0;	
		nCollimatorLeftVerticalEdge = 0;
		nCollimatorRightVerticalEdge = 0;	
		nCollimatorUpperHorizontalEdge = 0;
		nCollimatorLowerHorizontalEdge = 0;
		nCenterofCircularCollimator = 0;
		nRadiusofCircularCollimator = 0;	 
		nVerticesofthePolygonalCollimator = 0;
	}

	tagCollimatorInfo& operator=(const tagCollimatorInfo& txc)
	{
		nCollimatorShape = txc.nCollimatorShape;	
		nCollimatorLeftVerticalEdge = txc.nCollimatorLeftVerticalEdge;
		nCollimatorRightVerticalEdge = txc.nCollimatorRightVerticalEdge;	
		nCollimatorUpperHorizontalEdge = txc.nCollimatorUpperHorizontalEdge;
		nCollimatorLowerHorizontalEdge = txc.nCollimatorLowerHorizontalEdge;
		nCenterofCircularCollimator = txc.nCenterofCircularCollimator;
		nRadiusofCircularCollimator = txc.nRadiusofCircularCollimator;	 
		nVerticesofthePolygonalCollimator = txc.nVerticesofthePolygonalCollimator;

		return *this;
	}
}CollimatorInfo;

#define OtherInfoOffset	(CollimatorInfoOffset + CollimatorInfoLength)
typedef struct tagOtherInfo
{
	UINT					nFrameID;
	float					fBuckyRotateAngel;
	tagOtherInfo()
	{
		nFrameID = 0;
		fBuckyRotateAngel = 0;
	}
	tagOtherInfo& operator=(const tagOtherInfo& oih)
	{
		nFrameID = oih.nFrameID;
		fBuckyRotateAngel = oih.fBuckyRotateAngel;
		return *this;
	}
}OtherInfo;

typedef struct tagFrameHeader
{
	FrameGenInfo			stFrameGenInfo;
	FrameFPDInfo			stFrameFPDInfo;
	FrameTomoInfo			stFrameTomoInfo;
	FrameMaskInfo			stFrameMaskInfo;
	PositionInfo			stPositionInfo;
	CollimatorInfo			stCollimatorInfo;
	OtherInfo				stOtherInfo;


	tagFrameHeader()
	{
	
	}

	tagFrameHeader& operator=(const tagFrameHeader& tfh)
	{
		//
		stFrameGenInfo = tfh.stFrameGenInfo;
		stFrameFPDInfo = tfh.stFrameFPDInfo;
		stFrameTomoInfo = tfh.stFrameTomoInfo;
		stFrameMaskInfo = tfh.stFrameMaskInfo;
		stPositionInfo = tfh.stPositionInfo;
		stCollimatorInfo = tfh.stCollimatorInfo;
		stOtherInfo =  tfh.stOtherInfo;

		return *this;
	}
}FRAME_HEADER;

typedef struct tagDeviceShareMemHeader  
{ 
	double dPixelSpacingX;  
	double dPixelSpacingY;  
	FRAME_HEADER stFrameInfo;  
	
	tagDeviceShareMemHeader()  
	{  
		ZeroMemory(this, sizeof(tagDeviceShareMemHeader));  
	}  

	tagDeviceShareMemHeader& operator=(const tagDeviceShareMemHeader& tfh)  
	{  
		memcpy(this, &tfh, sizeof(tagDeviceShareMemHeader));  
		return *this;  
	}  
}DEVICESHAREMEM_HEADER;