// Parse the marker in from the JP2 file. CNCSError CNCSJPCRGNMarker::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { CNCSError Error; m_bHaveMarker = true; NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(ReadUINT16(m_nLength)); UINT8 t8; if(JPC.m_SIZ.m_nCsiz < 257) { NCSJP2_CHECKIO(ReadUINT8(t8)); m_nCrgn = t8; } else { NCSJP2_CHECKIO(ReadUINT16(m_nCrgn)); } NCSJP2_CHECKIO(ReadUINT8(t8)); if(t8 == 0x0) { m_eSrgn = IMPLICIT; NCSJP2_CHECKIO(ReadUINT8(m_nSPrgn)); } else { Error = NCS_FILEIO_ERROR; } if(Error == NCS_SUCCESS) { m_bValid = true; } NCSJP2_CHECKIO_END(); return(Error); }
// UnParse the box to the stream CNCSError CNCSJP2File::CNCSJP2SignatureBox::UnParse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream) { CNCSError Error; Error = CNCSJP2Box::UnParse(JP2File, Stream); NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(WriteUINT32(sm_JP2Signature)); NCSJP2_CHECKIO_END(); return(Error); }
CNCSError JP2UUID3DNBox::UnParse(CNCSJP2File &JP2File, CNCSJPCIOStream &Stream) { CNCSError Error; Error = CNCSJP2Box::UnParse(JP2File, Stream); NCSJP2_CHECKIO_BEGIN(Error, Stream); Stream.WriteIEEE8(_OrigMaxVal); Stream.WriteIEEE8(_OrigMinVal); Stream.WriteUINT32(_NormalizedMaxVal); Stream.WriteUINT32(_NormalizedMinVal); NCSJP2_CHECKIO_END(); return(Error); } // JP2UUID3DNBox::UnParse
// UnParse the marker out to the stream. CNCSError CNCSJPCSOPMarker::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { CNCSError Error; m_nLength = 4; NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO_ERROR(CNCSJPCMarker::UnParse(JPC, Stream)); NCSJP2_CHECKIO(WriteUINT16(m_nLength)); NCSJP2_CHECKIO(WriteUINT16(m_nNsop)); NCSJP2_CHECKIO_END(); return(Error); }
// UnParse the marker out to the stream. CNCSError CNCSJPCCRGMarker::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { CNCSError Error; Error = CNCSJPCMarker::UnParse(JPC, Stream); NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(WriteUINT16(m_nLength)); for(int i = 0; i < JPC.m_SIZ.m_nCsiz; i++) { NCSJP2_CHECKIO(WriteUINT16(m_Offsets[i].m_nXcrg)); NCSJP2_CHECKIO(WriteUINT16(m_Offsets[i].m_nYcrg)); } NCSJP2_CHECKIO_END(); return(Error); }
// UnParse the marker out to the stream. CNCSError CNCSJPCPPTMarker::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { CNCSError Error; Error = CNCSJPCMarker::UnParse(JPC, Stream); NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(WriteUINT16(m_nLength)); NCSJP2_CHECKIO(WriteUINT8(m_nZppt)); // for(UINT32 i = 0; i < m_Headers.size(); i++) { // NCSJP2_CHECKIO_ERROR(m_Headers[i].UnParse(JPC, Stream)); // } NCSJP2_CHECKIO_END(); return(Error); }
// Unparse the box out to the stream. CNCSError CNCSJP2File::CNCSJP2HeaderBox::CNCSJP2BitsPerComponentBox::UnParse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream) { CNCSError Error; // Setup the base box members // Write out the base box Error = CNCSJP2Box::UnParse(JP2File, Stream); NCSJP2_CHECKIO_BEGIN(Error, Stream); // For each component, write out the bit depth. for(UINT32 c = 0; c < m_Bits.size(); c++) { m_Bits[c].UnParse(JP2File.m_Codestream, Stream); } NCSJP2_CHECKIO_END(); return(Error); }
// Parse the marker in from the JP2 file. CNCSError CNCSJPCSOPMarker::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { CNCSError Error; Error = CNCSJPCMarker::Parse(JPC, Stream); if(Error == NCS_SUCCESS && m_eMarker == SOP) { m_bHaveMarker = true; NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(ReadUINT16(m_nLength)); NCSJP2_CHECKIO(ReadUINT16(m_nNsop)); m_bValid = true; NCSJP2_CHECKIO_END(); } return(NCS_SUCCESS); }
// Parse the box in from the stream CNCSError CNCSJP2File::CNCSJP2HeaderBox::CNCSJP2BitsPerComponentBox::Parse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream) { CNCSError Error; NCSJP2_CHECKIO_BEGIN(Error, Stream); // For each component in the image, read in the bit depth for(int c = 0; c < JP2File.m_Header.m_ImageHeader.m_nComponents; c++) { CNCSJPCComponentDepthType ci; NCSJP2_CHECKIO_ERROR(ci.Parse(JP2File.m_Codestream, Stream)); // Store the bit depth into the m_Bits member. m_Bits.push_back(ci); } m_bValid = true; NCSJP2_CHECKIO_END(); return(Error); }
// UnParse the color spec box out to the stream. CNCSError CNCSJP2File::CNCSJP2UUIDInfoBox::CNCSJP2UUIDListBox::UnParse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream) { CNCSError Error; // Setup the base box. m_nTBox = sm_nTBox; m_nXLBox = 8 + sizeof(UINT16) + m_nEntries * sizeof(m_UUIDs[0].m_UUID); // Write out the base box first Error = CNCSJP2Box::UnParse(JP2File, Stream); NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(WriteUINT16(m_nEntries)); for(int c = 0; c < m_nEntries; c++) { NCSJP2_CHECKIO(Write(m_UUIDs[c].m_UUID, sizeof(m_UUIDs[0].m_UUID))); } NCSJP2_CHECKIO_END(); return(Error); }
// Parse the box in from the stream. CNCSError CNCSJP2File::CNCSJP2UUIDInfoBox::CNCSJP2UUIDListBox::Parse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream) { CNCSError Error; NCSJP2_CHECKIO_BEGIN(Error, Stream); // Get the fields in NCSJP2_CHECKIO(ReadUINT16(m_nEntries)); for(int e = 0; e < m_nEntries; e++) { NCSUUID uuid; NCSJP2_CHECKIO(Read(&uuid.m_UUID, sizeof(uuid.m_UUID))); m_UUIDs.push_back(uuid); } m_bValid = true; NCSJP2_CHECKIO_END(); return(Error); }
// UnParse the marker out to the stream. CNCSError CNCSJPCComponentDepthType::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { &JPC;//Keep compiler happy CNCSError Error; NCSJP2_CHECKIO_BEGIN(Error, Stream); if(m_nBits != 255) { UINT8 nSsiz = m_nBits - 1; if(m_bSigned) { nSsiz |= 0x80; } NCSJP2_CHECKIO(WriteUINT8(nSsiz)); } else { NCSJP2_CHECKIO(WriteUINT8(255)); } NCSJP2_CHECKIO_END(); return(Error); }
// UnParse the box to the stream CNCSError CNCSJP2File::CNCSJP2GMLGeoLocationBox::UnParse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream) { #ifdef NCS_BUILD_WITH_STDERR_DEBUG_INFO fprintf(stderr,"UnParsing GML box information\n"); #endif char buf[1024]; CNCSError Error = FormatXML(buf, sizeof(buf)); if(Error == NCS_SUCCESS) { Error = CNCSJP2Box::UnParse(JP2File, Stream); NCSJP2_CHECKIO_BEGIN(Error, Stream); Stream.Write(buf, (UINT32)strlen(buf)); NCSJP2_CHECKIO_END(); } return(Error); }
// Parse the marker in from the JP2 file. CNCSError CNCSJPCComponentDepthType::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { &JPC;//Keep compiler happy CNCSError Error; NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(ReadUINT8(m_nBits)); if(m_nBits != 255) { if(m_nBits & 0x80) { m_bSigned = true; } else { m_bSigned = false; } m_nBits = (m_nBits & 0x7f) + 1; } NCSJP2_CHECKIO_END(); return(Error); }
// UnParse the marker out to the stream. CNCSError CNCSJPCRGNMarker::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { CNCSError Error; Error = CNCSJPCMarker::UnParse(JPC, Stream); NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(WriteUINT16(m_nLength)); if(JPC.m_SIZ.m_nCsiz < 257) { NCSJP2_CHECKIO(WriteUINT8((UINT8)m_nCrgn)); } else { NCSJP2_CHECKIO(WriteUINT16(m_nCrgn)); } NCSJP2_CHECKIO(WriteUINT8((UINT8)m_eSrgn)); NCSJP2_CHECKIO(WriteUINT8(m_nSPrgn)); NCSJP2_CHECKIO_END(); return(Error); }
// Parse the marker in from the JP2 file. CNCSError CNCSJPCPPTMarker::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { &JPC;//Keep compiler happy CNCSError Error; m_bHaveMarker = true; NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(ReadUINT16(m_nLength)); NCSJP2_CHECKIO(ReadUINT8(m_nZppt)); NCSJP2_CHECKIO(Seek(m_nLength - (sizeof(UINT16) + sizeof(UINT8)))); if(Error == NCS_SUCCESS) { m_bValid = true; } NCSJP2_CHECKIO_END(); return(Error); }
CNCSError JP2UUID3DNBox::Parse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream) { CNCSError Error; //See NCSJPCIOStream.h to get an understanding of these macros NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(Read(m_UUID.m_UUID, sizeof(m_UUID.m_UUID))); if (m_UUID == sm_UUID) { Stream.ReadIEEE8(_OrigMaxVal); Stream.ReadIEEE8(_OrigMinVal); Stream.ReadUINT32(_NormalizedMaxVal); Stream.ReadUINT32(_NormalizedMinVal); } // if NCSJP2_CHECKIO_END(); return(Error); } // JP2UUID3DNBox::Parse
// Parse the box from the stream CNCSError CNCSJP2File::CNCSJP2SignatureBox::Parse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream) { CNCSError Error; NCSJP2_CHECKIO_BEGIN(Error, Stream); // UINT8 buf[4]; // Read in the signature // NCSJP2_CHECKIO(Read(buf, 4)); UINT32 buf; NCSJP2_CHECKIO(ReadUINT32(buf)); if(memcmp(&sm_JP2Signature, &buf, sizeof(buf)) == 0) { // Signature is valid m_bValid = true; } else { Error = NCS_FILE_INVALID; } NCSJP2_CHECKIO_END(); return(Error); }
// Parse the marker in from the JP2 file. CNCSError CNCSJPCCRGMarker::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { CNCSError Error; m_bHaveMarker = true; NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO(ReadUINT16(m_nLength)); for(int i = 0; i < JPC.m_SIZ.m_nCsiz; i++) { Registration reg; NCSJP2_CHECKIO(ReadUINT16(reg.m_nXcrg)); NCSJP2_CHECKIO(ReadUINT16(reg.m_nYcrg)); m_Offsets.push_back(reg); } if(Error == NCS_SUCCESS) { m_bValid = true; } NCSJP2_CHECKIO_END(); return(Error); }
// UnParse the marker out to the stream. CNCSError CNCSJPCMainHeader::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { CNCSError Error; NCSJP2_CHECKIO_BEGIN(Error, Stream); NCSJP2_CHECKIO_ERROR(m_SOC.UnParse(JPC, Stream)); NCSJP2_CHECKIO_ERROR(m_SIZ.UnParse(JPC, Stream)); NCSJP2_CHECKIO_ERROR(m_COD.UnParse(JPC, Stream)); NCSJP2_CHECKIO_ERROR(m_QCD.UnParse(JPC, Stream)); NCSJP2_CHECKIO_ERROR(m_COM.UnParse(JPC, Stream)); if(false && m_COD.m_SGcod.m_bMCT) { CNCSJPCQCCMarker QCC = m_QuantizationStyles[1]; QCC.m_nCqcc = 1; // if( QCC.m_nLength = 5 + 3 * JPC.m_CodingStyles[1].m_SPcod.m_nLevels; NCSJP2_CHECKIO_ERROR(QCC.UnParse(JPC, Stream)); QCC = m_QuantizationStyles[2]; QCC.m_nCqcc = 2; NCSJP2_CHECKIO_ERROR(QCC.UnParse(JPC, Stream)); } NCSJP2_CHECKIO_END(); return(Error); }
// Parse the marker in from the JP2 file. CNCSError CNCSJPCMainHeader::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream) { CNCSError Error; CNCSJPCMarker marker; NCSJP2_CHECKIO_BEGIN(Error, Stream); Error = marker.Parse(JPC, Stream); if(Error == NCS_SUCCESS) { if(marker.m_eMarker == CNCSJPCMarker::SOC) { (CNCSJPCMarker&)m_SOC = marker; NCSJP2_CHECKIO_ERROR(m_SOC.Parse(JPC, Stream)); NCSJP2_CHECKIO_ERROR(marker.Parse(JPC, Stream)); if(marker.m_eMarker == CNCSJPCMarker::SIZ) { (CNCSJPCMarker&)m_SIZ = marker; NCSJP2_CHECKIO_ERROR(m_SIZ.Parse(JPC, Stream)); //initialize JPC.m_Tiles if( JPC.m_Tiles.size() == 0 ) { INT32 nNumTiles = JPC.GetNumXTiles() * JPC.GetNumYTiles(); JPC.m_Tiles.reserve( nNumTiles ); for( int i=0; i < nNumTiles; i++ ) { JPC.m_Tiles.push_back(NULL); } } while(Error == NCS_SUCCESS && !m_EOC.m_bValid) { NCSJP2_CHECKIO_ERROR(marker.Parse(JPC, Stream)); switch(marker.m_eMarker) { case CNCSJPCMarker::COD: if(!m_COD.m_bHaveMarker) { (CNCSJPCMarker&)m_COD = marker; NCSJP2_CHECKIO_ERROR(m_COD.Parse(JPC, Stream)); // Setup default coding style for each component m_CodingStyles.resize(m_SIZ.m_nCsiz, m_COD); } else { Error = NCS_FILEIO_ERROR; } break; case CNCSJPCMarker::COC: if(m_COD.m_bValid) { CNCSJPCCOCMarker COC; (CNCSJPCMarker&)COC = marker; NCSJP2_CHECKIO_ERROR(COC.Parse(JPC, Stream)); // Over-ride coding style for this component m_CodingStyles[COC.m_nCcoc] = COC; } else { // COD *must* be before COC Error = NCS_FILEIO_ERROR; } break; case CNCSJPCMarker::QCD: if(!m_QCD.m_bHaveMarker) { (CNCSJPCMarker&)m_QCD = marker; NCSJP2_CHECKIO_ERROR(m_QCD.Parse(JPC, Stream)); // Setup default coding style for each component m_QuantizationStyles.resize(m_SIZ.m_nCsiz, m_QCD); } else { Error = NCS_FILEIO_ERROR; } break; case CNCSJPCMarker::QCC: if(m_QCD.m_bValid) { CNCSJPCQCCMarker QCC; (CNCSJPCMarker&)QCC = marker; NCSJP2_CHECKIO_ERROR(QCC.Parse(JPC, Stream)); // Over-ride quantization style for this component m_QuantizationStyles[QCC.m_nCqcc] = QCC; } else { // QCD *must* be before QCC Error = NCS_FILEIO_ERROR; } break; case CNCSJPCMarker::RGN: { CNCSJPCRGNMarker RGN; (CNCSJPCMarker&)RGN = marker; NCSJP2_CHECKIO_ERROR(RGN.Parse(JPC, Stream)); m_RGNs.resize(m_SIZ.m_nCsiz); m_RGNs[RGN.m_nCrgn] = RGN; } break; case CNCSJPCMarker::POC: if(!m_POC.m_bHaveMarker) { (CNCSJPCMarker&)m_POC = marker; NCSJP2_CHECKIO_ERROR(m_POC.Parse(JPC, Stream)); } else { Error = NCS_FILEIO_ERROR; } break; case CNCSJPCMarker::PPM: if(true) { m_bFilePPMs = true; CNCSJPCPPMMarker PPM; (CNCSJPCMarker&)PPM = marker; NCSJP2_CHECKIO_ERROR(PPM.Parse(JPC, Stream)); m_PPMs.resize(NCSMax(m_PPMs.size(), (UINT32)PPM.m_nZppm + 1)); m_PPMs[PPM.m_nZppm] = PPM; } else { Error = NCS_FILEIO_ERROR; } break; case CNCSJPCMarker::TLM: { CNCSJPCTLMMarker TLM; (CNCSJPCMarker&)TLM = marker; NCSJP2_CHECKIO_ERROR(TLM.Parse(JPC, Stream)); m_TLMs.resize(NCSMax(m_TLMs.size(), (UINT32)TLM.m_nZtlm + 1)); m_TLMs[TLM.m_nZtlm] = TLM; } break; case CNCSJPCMarker::PLM: { CNCSJPCPLMMarker PLM; (CNCSJPCMarker&)PLM = marker; NCSJP2_CHECKIO_ERROR(PLM.Parse(JPC, Stream)); m_PLMs.resize(NCSMax(m_PLMs.size(), (UINT32)PLM.m_nZplm + 1)); m_PLMs[PLM.m_nZplm] = PLM; } break; case CNCSJPCMarker::CRG: if(!m_CRG.m_bHaveMarker) { (CNCSJPCMarker&)m_CRG = marker; NCSJP2_CHECKIO_ERROR(m_CRG.Parse(JPC, Stream)); } else { // Can only have one CRG marker in the codestream Error = NCS_FILEIO_ERROR; } break; case CNCSJPCMarker::SOT: { CNCSJPCTilePartHeader *pTP = new CNCSJPCTilePartHeader(&JPC); if(pTP) { (CNCSJPCMarker&)pTP->m_SOT = marker; JPC.m_pCurrentTilePart = pTP; NCSJP2_CHECKIO_ERROR(pTP->Parse(JPC, Stream)); if( pTP->m_SOT.m_nTPsot == 0 ) { //first tile part if( JPC.m_Tiles[pTP->m_SOT.m_nIsot] == NULL ) { JPC.m_Tiles[pTP->m_SOT.m_nIsot] = pTP; } else { // Got TP twice, just ignore. delete pTP; } } else if( JPC.m_Tiles[pTP->m_SOT.m_nIsot] ) { // other parts if( (JPC.m_Tiles[pTP->m_SOT.m_nIsot]->m_TileParts.size() >= (pTP->m_SOT.m_nTPsot)) && (JPC.m_Tiles[pTP->m_SOT.m_nIsot]->m_TileParts[pTP->m_SOT.m_nTPsot] != NULL) ) { // Got TP twice, just ignore. delete pTP; } else { JPC.m_Tiles[pTP->m_SOT.m_nIsot]->m_TileParts.push_back(pTP); } } else { // this shouldn't happen Error = NCS_COULDNT_ALLOC_MEMORY; } } else { Error = NCS_COULDNT_ALLOC_MEMORY; } } break; case CNCSJPCMarker::COM: { CNCSJPCCOMMarker COM; (CNCSJPCMarker&)COM = marker; NCSJP2_CHECKIO_ERROR(COM.Parse(JPC, Stream)); } break; case CNCSJPCMarker::EOC: if(!m_EOC.m_bHaveMarker) { (CNCSJPCMarker&)m_EOC = marker; NCSJP2_CHECKIO_ERROR(m_EOC.Parse(JPC, Stream)); } else { Error = NCS_FILEIO_ERROR; } break; default: if(marker.m_eMarker >= 0xff30 && marker.m_eMarker <= 0xff3f) { // Skip } else { Error = NCS_FILEIO_ERROR; } break; } } // if(Error == NCS_SUCCESS) { if(m_SOC.m_bValid && m_SIZ.m_bValid && m_COD.m_bValid && (JPC.m_pStream->IsPacketStream() || (JPC.m_pCurrentTilePart && JPC.m_pCurrentTilePart->m_SOT.m_bValid))) { m_bValid = true; Error = NCS_SUCCESS; } // } CNCSJPCTilePartHeader *pTP = JPC.GetTile(0); while(pTP) { if(pTP->m_bFilePPTs) { JPC.m_pCurrentTilePart = pTP; bool bComplete = false; CNCSJPCPacketList Packets; Error = Packets.Parse(JPC, Stream, bComplete, (UINT64)-1); if(Error == NCS_SUCCESS) { Error = Packets.GenDynamicPLTs(pTP); Packets.clear(); } } pTP = JPC.GetTile(pTP->m_SOT.m_nIsot + 1); } } else { Error = NCS_FILE_INVALID; } } else { Error = NCS_FILE_INVALID; } } if(Error == NCS_SUCCESS) { for(int y = 0; y < GetNumYTiles(); y++) { for(int x = 0; x < GetNumXTiles(); x++) { CNCSJPCTilePartHeader *pTP = JPC.GetTile(x + y * GetNumXTiles()); if(pTP) { pTP->m_nCurPacket = pTP->GetFirstPacketNr(); } } } } NCSJP2_CHECKIO_END(); return(Error); }
// Parse the box from the stream CNCSError CNCSJP2File::CNCSJP2GMLGeoLocationBox::Parse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream) { #ifdef NCS_BUILD_WITH_STDERR_DEBUG_INFO fprintf(stderr,"Parsing GML box information\n"); #endif CNCSError Error(NCS_SUCCESS); m_bValid = false; double dRegX = 0.0; double dRegY = 0.0; double p1[3]; double p2[3]; UINT32 nEPSGCode = 0; int nResults = 0; bool bSRSAttributePresent = false; UINT32 nImageWidth = JP2File.m_FileInfo.nSizeX; UINT32 nImageHeight = JP2File.m_FileInfo.nSizeY; NCSJP2_CHECKIO_BEGIN(Error, Stream); char buf[1024 + 1]; Stream.Read(buf, NCSMin((UINT32)m_nLDBox, sizeof(buf)-1)); buf[NCSMin((UINT32)m_nLDBox, sizeof(buf)-1)] = '\0'; TiXmlDocument doc; doc.Parse(buf); TiXmlHandle docHandle(&doc); TiXmlElement *GeoLocation_1 = docHandle.FirstChild("JPEG2000_GeoLocation").FirstChild("gml:RectifiedGrid").Element();//.FirstChild( "Element" ).Child( "Child", 1 ).Element(); if(GeoLocation_1 && GeoLocation_1->Attribute("gml:id") && !stricmp(GeoLocation_1->Attribute("gml:id"), "JPEG2000_GeoLocation_1")) { TiXmlElement *OriginPoint = docHandle.FirstChild("JPEG2000_GeoLocation").FirstChild("gml:RectifiedGrid").FirstChild("gml:origin").FirstChild("gml:Point").Element(); if(OriginPoint && OriginPoint->Attribute("gml:id") && !stricmp(OriginPoint->Attribute("gml:id"), "JPEG2000_Origin")) { const char *pTxt = OriginPoint->Attribute("srsName"); if(pTxt) { nResults += sscanf(pTxt, "epsg:%u", &nEPSGCode); bSRSAttributePresent = true; } TiXmlText *Coords = docHandle.FirstChild("JPEG2000_GeoLocation").FirstChild("gml:RectifiedGrid").FirstChild("gml:origin").FirstChild("gml:Point").FirstChild("gml:coordinates").FirstChild().Text(); if(Coords) { pTxt = Coords->Value(); if(pTxt) { nResults += sscanf(pTxt, "%lf,%lf", &dRegX, &dRegY); } } } TiXmlElement *offsetVector = docHandle.FirstChild("JPEG2000_GeoLocation").FirstChild("gml:RectifiedGrid").FirstChild("gml:offsetVector").Element(); if(offsetVector && offsetVector->Attribute("gml:id") && !stricmp(offsetVector->Attribute("gml:id"), "p1")) { TiXmlText *Coords = docHandle.FirstChild("JPEG2000_GeoLocation").FirstChild("gml:RectifiedGrid").FirstChild("gml:offsetVector").FirstChild().Text(); if(Coords) { const char *pTxt = Coords->Value(); if(pTxt) { nResults += sscanf(pTxt, "%lf,%lf,%lf", &p1[0], &p1[1], &p1[2]); } } offsetVector = (TiXmlElement*)offsetVector->NextSibling("gml:offsetVector"); if(offsetVector && offsetVector->Attribute("gml:id") && !stricmp(offsetVector->Attribute("gml:id"), "p2")) { TiXmlText *Coords = ((TiXmlElement*)offsetVector->FirstChild())->ToText(); if(Coords) { const char *pTxt = Coords->Value(); if(pTxt) { nResults += sscanf(pTxt, "%lf,%lf,%lf", &p2[0], &p2[1], &p2[2]); } } } } } NCSJP2_CHECKIO_END(); if((nResults == 9 && bSRSAttributePresent) || (nResults == 8 && !bSRSAttributePresent)) { IEEE8 dRegistrationX = dRegX + nImageHeight * p1[0]; IEEE8 dRegistrationY = dRegY + nImageHeight * p1[1]; if(p1[2] == 0.0 && p2[2] == 0.0) { // p1[0] = sin(Deg2Rad(dCWRotationDegrees)) * dCellSizeX; // p1[1] = cos(Deg2Rad(dCWRotationDegrees)) * dCellSizeY; // p2[0] = cos(Deg2Rad(dCWRotationDegrees)) * dCellSizeX; // p2[1] = -sin(Deg2Rad(dCWRotationDegrees)) * dCellSizeY; double dCWRotationDegrees = Rad2Deg(atan(p1[0] / p2[0])); double dCellSizeX = p2[0] / cos(atan(p1[0] / p2[0])); double dCellSizeY = p1[1] / cos(atan(p1[0] / p2[0])); m_GMLFileInfo.fOriginX = dRegistrationX; m_GMLFileInfo.fOriginY = dRegistrationY; m_GMLFileInfo.fCellIncrementX = dCellSizeX; m_GMLFileInfo.fCellIncrementY = dCellSizeY; m_GMLFileInfo.fCWRotationDegrees = dCWRotationDegrees; CNCSGDTEPSG& Epsg = *CNCSGDTEPSG::Instance(); char *pProjection = NULL; char *pDatum = NULL; NCSFree(m_GMLFileInfo.szProjection); NCSFree(m_GMLFileInfo.szDatum); if (bSRSAttributePresent && nEPSGCode && (Epsg.GetProjectionAndDatum(nEPSGCode, &pProjection, &pDatum) == NCS_SUCCESS)) { if(pProjection && pDatum) { m_GMLFileInfo.szProjection= NCSStrDup(pProjection); m_GMLFileInfo.szDatum = NCSStrDup(pDatum); NCSFree(pProjection); NCSFree(pDatum); } else if (nEPSGCode) //EPSG code present but invalid or unrecognised? { char szEPSG[32]; *szEPSG = '\0'; sprintf(szEPSG,"epsg:%u",nEPSGCode); m_GMLFileInfo.szProjection = NCSStrDup(szEPSG); m_GMLFileInfo.szDatum = NCSStrDup(szEPSG); } } else { m_GMLFileInfo.szDatum = NCSStrDup("RAW"); m_GMLFileInfo.szProjection = NCSStrDup("RAW"); } if(stricmp(m_GMLFileInfo.szProjection, "GEODETIC") == 0) m_GMLFileInfo.eCellSizeUnits = ECW_CELL_UNITS_DEGREES; else m_GMLFileInfo.eCellSizeUnits = ECW_CELL_UNITS_METERS; } else return NCS_JP2_GEODATA_READ_ERROR; } else return NCS_JP2_GEODATA_READ_ERROR; m_bValid = true; NCSStandardizeFileInfoEx(&m_GMLFileInfo); return NCS_SUCCESS; }