/********************************************************************** * $Id: mitab_mapcoordblock.cpp,v 1.14 2005/10/06 19:15:31 dmorissette Exp $ * * Name: mitab_mapcoordblock.cpp * Project: MapInfo TAB Read/Write library * Language: C++ * Purpose: Implementation of the TABMAPCoordBlock class used to handle * reading/writing of the .MAP files' coordinate blocks * Author: Daniel Morissette, dmorissette@dmsolutions.ca * ********************************************************************** * Copyright (c) 1999-2001, Daniel Morissette * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. ********************************************************************** * * $Log: mitab_mapcoordblock.cpp,v $ * Revision 1.14 2005/10/06 19:15:31 dmorissette * Collections: added support for reading/writing pen/brush/symbol ids and * for writing collection objects to .TAB/.MAP (bug 1126) * * Revision 1.13 2004/06/30 20:29:04 dmorissette * Fixed refs to old address danmo@videotron.ca * * Revision 1.12 2002/08/27 17:18:23 warmerda * improved CPL error testing * * Revision 1.11 2001/11/17 21:54:06 daniel * Made several changes in order to support writing objects in 16 bits coordinate format. * New TABMAPObjHdr-derived classes are used to hold object info in mem until block is full. * * Revision 1.10 2001/05/09 17:45:12 daniel * Support reading and writing data blocks > 512 bytes (for text objects). * * Revision 1.9 2000/10/10 19:05:12 daniel * Fixed ReadBytes() to allow strings overlapping on 2 blocks * * Revision 1.8 2000/02/28 16:58:55 daniel * Added V450 object types with num_points > 32767 and pen width in points * * Revision 1.7 2000/01/15 22:30:44 daniel * Switch to MIT/X-Consortium OpenSource license * * Revision 1.6 1999/11/08 04:29:31 daniel * Fixed problem with compressed coord. offset for regions and multiplines * * Revision 1.5 1999/10/06 15:19:11 daniel * Do not automatically init. curr. feature MBR when block is initialized * * Revision 1.4 1999/10/06 13:18:55 daniel * Fixed uninitialized class members * * Revision 1.3 1999/09/29 04:25:42 daniel * Fixed typo in GetFeatureMBR() * * Revision 1.2 1999/09/26 14:59:36 daniel * Implemented write support * * Revision 1.1 1999/07/12 04:18:24 daniel * Initial checkin * **********************************************************************/ #include "mitab.h" /*===================================================================== * class TABMAPCoordBlock *====================================================================*/ #define MAP_COORD_HEADER_SIZE 8 /********************************************************************** * TABMAPCoordBlock::TABMAPCoordBlock() * * Constructor. **********************************************************************/ TABMAPCoordBlock::TABMAPCoordBlock(TABAccess eAccessMode /*= TABRead*/): TABRawBinBlock(eAccessMode, TRUE) { m_nComprOrgX = m_nComprOrgY = m_nNextCoordBlock = m_numDataBytes = 0; m_numBlocksInChain = 1; // Current block counts as 1 m_poBlockManagerRef = NULL; m_nTotalDataSize = 0; m_nFeatureDataSize = 0; m_nFeatureXMin = m_nMinX = 1000000000; m_nFeatureYMin = m_nMinY = 1000000000; m_nFeatureXMax = m_nMaxX = -1000000000; m_nFeatureYMax = m_nMaxY = -1000000000; } /********************************************************************** * TABMAPCoordBlock::~TABMAPCoordBlock() * * Destructor. **********************************************************************/ TABMAPCoordBlock::~TABMAPCoordBlock() { } /********************************************************************** * TABMAPCoordBlock::InitBlockFromData() * * Perform some initialization on the block after its binary data has * been set or changed (or loaded from a file). * * Returns 0 if succesful or -1 if an error happened, in which case * CPLError() will have been called. **********************************************************************/ int TABMAPCoordBlock::InitBlockFromData(GByte *pabyBuf, int nSize, GBool bMakeCopy /* = TRUE */, FILE *fpSrc /* = NULL */, int nOffset /* = 0 */) { int nStatus; /*----------------------------------------------------------------- * First of all, we must call the base class' InitBlockFromData() *----------------------------------------------------------------*/ nStatus = TABRawBinBlock::InitBlockFromData(pabyBuf, nSize, bMakeCopy, fpSrc, nOffset); if (nStatus != 0) return nStatus; /*----------------------------------------------------------------- * Validate block type *----------------------------------------------------------------*/ if (m_nBlockType != TABMAP_COORD_BLOCK) { CPLError(CE_Failure, CPLE_FileIO, "InitBlockFromData(): Invalid Block Type: got %d expected %d", m_nBlockType, TABMAP_COORD_BLOCK); CPLFree(m_pabyBuf); m_pabyBuf = NULL; return -1; } /*----------------------------------------------------------------- * Init member variables *----------------------------------------------------------------*/ GotoByteInBlock(0x002); m_numDataBytes = ReadInt16(); /* Excluding 8 bytes header */ m_nNextCoordBlock = ReadInt32(); // Set the real SizeUsed based on numDataBytes m_nSizeUsed = m_numDataBytes + MAP_COORD_HEADER_SIZE; /*----------------------------------------------------------------- * The read ptr is now located at the beginning of the data part. *----------------------------------------------------------------*/ GotoByteInBlock(MAP_COORD_HEADER_SIZE); return 0; } /********************************************************************** * TABMAPCoordBlock::CommitToFile() * * Commit the current state of the binary block to the file to which * it has been previously attached. * * This method makes sure all values are properly set in the map object * block header and then calls TABRawBinBlock::CommitToFile() to do * the actual writing to disk. * * Returns 0 if succesful or -1 if an error happened, in which case * CPLError() will have been called. **********************************************************************/ int TABMAPCoordBlock::CommitToFile() { int nStatus = 0; CPLErrorReset(); if ( m_pabyBuf == NULL ) { CPLError(CE_Failure, CPLE_AssertionFailed, "CommitToFile(): Block has not been initialized yet!"); return -1; } /*----------------------------------------------------------------- * Make sure 8 bytes block header is up to date. *----------------------------------------------------------------*/ GotoByteInBlock(0x000); WriteInt16(TABMAP_COORD_BLOCK); // Block type code WriteInt16(m_nSizeUsed - MAP_COORD_HEADER_SIZE); // num. bytes used WriteInt32(m_nNextCoordBlock); if( CPLGetLastErrorType() == CE_Failure ) nStatus = CPLGetLastErrorNo(); /*----------------------------------------------------------------- * OK, call the base class to write the block to disk. *----------------------------------------------------------------*/ if (nStatus == 0) nStatus = TABRawBinBlock::CommitToFile(); return nStatus; } /********************************************************************** * TABMAPCoordBlock::InitNewBlock() * * Initialize a newly created block so that it knows to which file it * is attached, its block size, etc . and then perform any specific * initialization for this block type, including writing a default * block header, etc. and leave the block ready to receive data. * * This is an alternative to calling ReadFromFile() or InitBlockFromData() * that puts the block in a stable state without loading any initial * data in it. * * Returns 0 if succesful or -1 if an error happened, in which case * CPLError() will have been called. **********************************************************************/ int TABMAPCoordBlock::InitNewBlock(FILE *fpSrc, int nBlockSize, int nFileOffset /* = 0*/) { CPLErrorReset(); /*----------------------------------------------------------------- * Start with the default initialisation *----------------------------------------------------------------*/ if ( TABRawBinBlock::InitNewBlock(fpSrc, nBlockSize, nFileOffset) != 0) return -1; /*----------------------------------------------------------------- * And then set default values for the block header. * * IMPORTANT: Do not reset m_nComprOrg here because its value needs to be * maintained between blocks in the same chain. *----------------------------------------------------------------*/ m_nNextCoordBlock = 0; m_numDataBytes = 0; // m_nMin/Max are used to keep track of current block MBR // FeatureMin/Max should not be reset here since feature coords can // be split on several blocks m_nMinX = 1000000000; m_nMinY = 1000000000; m_nMaxX = -1000000000; m_nMaxY = -1000000000; if (m_eAccess != TABRead) { GotoByteInBlock(0x000); WriteInt16(TABMAP_COORD_BLOCK); // Block type code WriteInt16(0); // num. bytes used, excluding header WriteInt32(0); // Pointer to next coord block } if (CPLGetLastErrorType() == CE_Failure ) return -1; return 0; } /********************************************************************** * TABMAPObjectBlock::SetNextCoordBlock() * * Set the address (offset from beginning of file) of the coord. block * that follows the current one. **********************************************************************/ void TABMAPCoordBlock::SetNextCoordBlock(GInt32 nNextCoordBlockAddress) { m_nNextCoordBlock = nNextCoordBlockAddress; } /********************************************************************** * TABMAPObjectBlock::SetComprCoordOrigin() * * Set the Compressed integer coordinates space origin to be used when * reading compressed coordinates using ReadIntCoord(). **********************************************************************/ void TABMAPCoordBlock::SetComprCoordOrigin(GInt32 nX, GInt32 nY) { m_nComprOrgX = nX; m_nComprOrgY = nY; } /********************************************************************** * TABMAPObjectBlock::ReadIntCoord() * * Read the next pair of integer coordinates value from the block, and * apply the translation relative to the origin of the coord. space * previously set using SetComprCoordOrigin() if bCompressed=TRUE. * * This means that the returned coordinates are always absolute integer * coordinates, even when the source coords are in compressed form. * * Returns 0 if succesful or -1 if an error happened, in which case * CPLError() will have been called. **********************************************************************/ int TABMAPCoordBlock::ReadIntCoord(GBool bCompressed, GInt32 &nX, GInt32 &nY) { if (bCompressed) { nX = m_nComprOrgX + ReadInt16(); nY = m_nComprOrgY + ReadInt16(); } else { nX = ReadInt32(); nY = ReadInt32(); } if (CPLGetLastErrorType() == CE_Failure) return -1; return 0; } /********************************************************************** * TABMAPObjectBlock::ReadIntCoords() * * Read the specified number of pairs of X,Y integer coordinates values * from the block, and apply the translation relative to the origin of * the coord. space previously set using SetComprCoordOrigin() if * bCompressed=TRUE. * * This means that the returned coordinates are always absolute integer * coordinates, even when the source coords are in compressed form. * * panXY should point to an array big enough to receive the specified * number of coordinates. * * Returns 0 if succesful or -1 if an error happened, in which case * CPLError() will have been called. **********************************************************************/ int TABMAPCoordBlock::ReadIntCoords(GBool bCompressed, int numCoordPairs, GInt32 *panXY) { int i, numValues = numCoordPairs*2; if (bCompressed) { for(i=0; i numVerticesTotal) { CPLError(CE_Failure, CPLE_AssertionFailed, "Unsupported case or corrupt file: MULTIPLINE/REGION " "object vertices do not appear to be grouped together."); return -1; } } return 0; } /********************************************************************** * TABMAPObjectBlock::WriteCoordSecHdrs() * * Write a set of coordinate section headers for PLINE MULTIPLE or REGIONs. * pasHdrs should point to an array of numSections TABMAPCoordSecHdr * structures that have been properly initialized. * * In V450 the numVertices is stored on an int32 instead of an int16 * * At the end of the call, this TABMAPCoordBlock object will be ready to * receive the coordinate data. * * Returns 0 if succesful or -1 if an error happened, in which case * CPLError() will have been called. **********************************************************************/ int TABMAPCoordBlock::WriteCoordSecHdrs(GBool bV450Hdr, int numSections, TABMAPCoordSecHdr *pasHdrs, GBool bCompressed /*=FALSE*/) { int i; CPLErrorReset(); for(i=0; i m_nMaxX) m_nMaxX = nX; if (nY < m_nMinY) m_nMinY = nY; if (nY > m_nMaxY) m_nMaxY = nY; /*------------------------------------------------------------- * Also keep track of current feature MBR. *------------------------------------------------------------*/ if (nX < m_nFeatureXMin) m_nFeatureXMin = nX; if (nX > m_nFeatureXMax) m_nFeatureXMax = nX; if (nY < m_nFeatureYMin) m_nFeatureYMin = nY; if (nY > m_nFeatureYMax) m_nFeatureYMax = nY; return 0; } /********************************************************************** * TABMAPCoordBlock::SetMAPBlockManagerRef() * * Pass a reference to the block manager object for the file this * block belongs to. The block manager will be used by this object * when it needs to automatically allocate a new block. **********************************************************************/ void TABMAPCoordBlock::SetMAPBlockManagerRef(TABBinBlockManager *poBlockMgr) { m_poBlockManagerRef = poBlockMgr; }; /********************************************************************** * TABMAPCoordBlock::ReadBytes() * * Cover function for TABRawBinBlock::ReadBytes() that will automagically * load the next coordinate block in the chain before reading the * requested bytes if we are at the end of the current block and if * m_nNextCoordBlock is a valid block. * * Then the control is passed to TABRawBinBlock::ReadBytes() to finish the * work: * Copy the number of bytes from the data block's internal buffer to * the user's buffer pointed by pabyDstBuf. * * Passing pabyDstBuf = NULL will only move the read pointer by the * specified number of bytes as if the copy had happened... but it * won't crash. * * Returns 0 if succesful or -1 if an error happened, in which case * CPLError() will have been called. **********************************************************************/ int TABMAPCoordBlock::ReadBytes(int numBytes, GByte *pabyDstBuf) { int nStatus; if (m_pabyBuf && m_nCurPos >= (m_numDataBytes+MAP_COORD_HEADER_SIZE) && m_nNextCoordBlock > 0) { // We're at end of current block... advance to next block. if ( (nStatus=GotoByteInFile(m_nNextCoordBlock)) != 0) { // Failed.... an error has already been reported. return nStatus; } GotoByteInBlock(MAP_COORD_HEADER_SIZE); // Move pointer past header m_numBlocksInChain++; } if (m_pabyBuf && m_nCurPos < (m_numDataBytes+MAP_COORD_HEADER_SIZE) && m_nCurPos+numBytes > (m_numDataBytes+MAP_COORD_HEADER_SIZE) && m_nNextCoordBlock > 0) { // Data overlaps on more than one block // Read until end of this block and then recursively call ReadBytes() // for the rest. int numBytesInThisBlock = (m_numDataBytes+MAP_COORD_HEADER_SIZE)-m_nCurPos; nStatus = TABRawBinBlock::ReadBytes(numBytesInThisBlock, pabyDstBuf); if (nStatus == 0) nStatus = TABMAPCoordBlock::ReadBytes(numBytes-numBytesInThisBlock, pabyDstBuf+numBytesInThisBlock); return nStatus; } return TABRawBinBlock::ReadBytes(numBytes, pabyDstBuf); } /********************************************************************** * TABMAPCoordBlock::WriteBytes() * * Cover function for TABRawBinBlock::WriteBytes() that will automagically * CommitToFile() the current block and create a new one if we are at * the end of the current block. * * Then the control is passed to TABRawBinBlock::WriteBytes() to finish the * work. * * Passing pabySrcBuf = NULL will only move the write pointer by the * specified number of bytes as if the copy had happened... but it * won't crash. * * Returns 0 if succesful or -1 if an error happened, in which case * CPLError() will have been called. **********************************************************************/ int TABMAPCoordBlock::WriteBytes(int nBytesToWrite, GByte *pabySrcBuf) { if (m_eAccess != TABWrite && m_eAccess != TABReadWrite ) { CPLError(CE_Failure, CPLE_AppDefined, "WriteBytes(): Block does not support write operations."); return -1; } if (m_poBlockManagerRef && (m_nBlockSize - m_nCurPos) < nBytesToWrite) { if (nBytesToWrite <= (m_nBlockSize-MAP_COORD_HEADER_SIZE)) { // Data won't fit in this block but can fit inside a single // block, so we'll allocate a new block for it. This will // prevent us from overlapping coordinate values on 2 blocks, but // still allows strings longer than one block (see 'else' below). // int nNewBlockOffset = m_poBlockManagerRef->AllocNewBlock(); SetNextCoordBlock(nNewBlockOffset); if (CommitToFile() != 0 || InitNewBlock(m_fp, 512, nNewBlockOffset) != 0) { // An error message should have already been reported. return -1; } m_numBlocksInChain++; } else { // Data to write is longer than one block... so we'll have to // split it over multiple block through multiple calls. // int nStatus = 0; while(nStatus == 0 && nBytesToWrite > 0) { int nBytes = m_nBlockSize-MAP_COORD_HEADER_SIZE; if ( (m_nBlockSize - m_nCurPos) > 0 ) { // Use free room in current block nBytes = (m_nBlockSize - m_nCurPos); } nBytes = MIN(nBytes, nBytesToWrite); // The following call will result in a new block being // allocated in the if() block above. nStatus = TABMAPCoordBlock::WriteBytes(nBytes, pabySrcBuf); nBytesToWrite -= nBytes; pabySrcBuf += nBytes; } return nStatus; } } if (m_nCurPos >= MAP_COORD_HEADER_SIZE) { // Keep track of Coordinate data... this means ignore header bytes // that could be written. m_nTotalDataSize += nBytesToWrite; m_nFeatureDataSize += nBytesToWrite; } return TABRawBinBlock::WriteBytes(nBytesToWrite, pabySrcBuf); } /********************************************************************** * TABMAPCoordBlock::StartNewFeature() * * Reset all member vars that are used to keep track of data size * and MBR for the current feature. This is info is not needed by * the coord blocks themselves, but it helps a lot the callers to * have this class take care of that for them. * * See Also: GetFeatureDataSize() and GetFeatureMBR() **********************************************************************/ void TABMAPCoordBlock::StartNewFeature() { m_nFeatureDataSize = 0; m_nFeatureXMin = 1000000000; m_nFeatureYMin = 1000000000; m_nFeatureXMax = -1000000000; m_nFeatureYMax = -1000000000; } /********************************************************************** * TABMAPCoordBlock::GetFeatureMBR() * * Return the MBR of all the coords written using WriteIntCoord() since * the last call to StartNewFeature(). **********************************************************************/ void TABMAPCoordBlock::GetFeatureMBR(GInt32 &nXMin, GInt32 &nYMin, GInt32 &nXMax, GInt32 &nYMax) { nXMin = m_nFeatureXMin; nYMin = m_nFeatureYMin; nXMax = m_nFeatureXMax; nYMax = m_nFeatureYMax; } /********************************************************************** * TABMAPCoordBlock::Dump() * * Dump block contents... available only in DEBUG mode. **********************************************************************/ #ifdef DEBUG void TABMAPCoordBlock::Dump(FILE *fpOut /*=NULL*/) { if (fpOut == NULL) fpOut = stdout; fprintf(fpOut, "----- TABMAPCoordBlock::Dump() -----\n"); if (m_pabyBuf == NULL) { fprintf(fpOut, "Block has not been initialized yet."); } else { fprintf(fpOut,"Coordinate Block (type %d) at offset %d.\n", m_nBlockType, m_nFileOffset); fprintf(fpOut," m_numDataBytes = %d\n", m_numDataBytes); fprintf(fpOut," m_nNextCoordBlock = %d\n", m_nNextCoordBlock); } fflush(fpOut); } #endif // DEBUG