SEGMENTH CombinePolygonPieces(SEGMENTH *A1, SEGMENTH *B1,
Boolean keepAinB, Boolean keepAnotinB,
Boolean keepBinA, Boolean keepBnotinA)
{
long i, j, err, numSegsA, numSegsB, numSegsC = 0;
WorldPoint m;
SEGMENTH C = 0, A2 = 0, B2 = 0, *A = 0, *B = 0;
err = 0;
numSegsA = _GetHandleSize((Handle)*A1) / sizeof(Segment);
numSegsB = _GetHandleSize((Handle)*B1) / sizeof(Segment);
A2 = (SEGMENTH)_NewHandle(numSegsA * sizeof(Segment));
if (_MemError()) { TechError("CombinePolygonPieces()", "_NewHandle()", 0); goto done; }
for (i = 0 ; i < numSegsA ; i++)
INDEXH(A2, i) = INDEXH(*A1, i);
A = &A2;
B2 = (SEGMENTH)_NewHandle(numSegsB * sizeof(Segment));
if (_MemError()) { TechError("CombinePolygonPieces()", "_NewHandle()", 0); goto done; }
for (i = 0 ; i < numSegsB ; i++)
INDEXH(B2, i) = INDEXH(*B1, i);
B = &B2;
for (i = 0 ; i < numSegsA ; i++)
for (j = 0 ; j < numSegsB ; j++)
if (SegmentTouchesSegment(INDEXH(*A, i), INDEXH(*B, j)) &&
!SameSegmentEndPoints(INDEXH(*A, i), INDEXH(*B, j))) {
m = PointOfIntersection(INDEXH(*A, i), INDEXH(*B, j));
if (err = InsertSegment(A, &numSegsA, i, m)) goto done;
if (err = InsertSegment(B, &numSegsB, j, m)) goto done;
}
C = (SEGMENTH)_NewHandle(0);
if (_MemError()) { TechError("CombinePolygonPieces()", "_NewHandle()", 0); goto done; }
for (i = 0 ; i < numSegsA ; i++) {
m = Midpoint(INDEXH(*A, i));
if ((keepAinB && PointInPolygon(m, *B, numSegsB, TRUE)) ||
(keepAnotinB && !PointInPolygon(m, *B, numSegsB, TRUE)))
if (err = AddSegment(&C, &numSegsC, INDEXH(*A, i))) goto done;
}
for (j = 0 ; j < numSegsB ; j++) {
m = Midpoint(INDEXH(*B, j));
if ((keepBinA && PointInPolygon(m, *A, numSegsA, TRUE)) ||
(keepBnotinA && !PointInPolygon(m, *A, numSegsA, TRUE)))
if (err = AddSegment(&C, &numSegsC, INDEXH(*B, j))) goto done;
}
SortSegments(C, numSegsC);
done:
if (A2) DisposeHandle((Handle)A2);
if (B2) DisposeHandle((Handle)B2);
if (err && C) DisposeHandle((Handle)C);
return err ? 0 : C;
}
nsresult sbSeekableChannel::InsertSegment(
Segment *pInsertSegment)
{
DataSet::iterator dataSetIterator;
Segment *pSegment = NULL;
nsresult result = NS_OK;
/* Find the first intersecting data segment and merge with it. If new */
/* data segment does not intersect any other data segments, simply insert */
/* it into data set. */
dataSetIterator = mChannelData.find(pInsertSegment);
if (dataSetIterator != mChannelData.end())
{
pSegment = *dataSetIterator;
mChannelData.erase(pSegment);
result = MergeSegments(pSegment, pInsertSegment, &pSegment);
InsertSegment(pSegment);
}
else
{
mChannelData.insert(pInsertSegment);
}
return (result);
}
bool HexDoc::InsertAt(THSIZE nIndex, const uint8 *psrc, int nSize, THSIZE nCount /*= 1*/, int flags /*= 0*/)
{
if (!(flags & SUPPRESS_UPDATE) && !CanReplaceAt(nIndex, 0, nSize * nCount))
return false;
if (nSize == 0 || nCount == 0)
return true; // nothing to do
//! todo: if we can append to the preceding block, do that instead?
Segment *ts = new Segment(nSize * nCount);
if (!ts || !ts->pData)
return false;
// copy data to the newly allocated block
if (nSize == 1)
memset(ts->pData, *psrc, nCount); //! todo: use fill data?
else for (int i = 0; i < nCount; i++)
memcpy(ts->pData + i * nSize, psrc, nSize);
if (!InsertSegment(nIndex, ts))
return false;
m_iChangeIndex++;
if (hw && !(flags & SUPPRESS_UPDATE))
hw->OnDataChange(nIndex, 0, nSize * nCount);
return true;
}
bool HexDoc::ReplaceSerialized(THSIZE nAddress, THSIZE ToReplaceLength, SerialData &sInsert)
{
if (!sInsert.Ok()) // not an error if len == 0
return false;
if (!CanReplaceAt(nAddress, ToReplaceLength, sInsert.m_nTotalSize))
return false;
if (!RemoveAt(nAddress, ToReplaceLength, SUPPRESS_UPDATE))
return false;
//! todo: get data sources
for (int iSeg = 0; iSeg < sInsert.hdr.nSegments; iSeg++)
{
Segment *ts = Segment::Unserialize(sInsert, iSeg);
InsertSegment(nAddress, ts);
nAddress += ts->size;
}
m_iChangeIndex++;
if (hw)
hw->OnDataChange(nAddress, ToReplaceLength, sInsert.m_nTotalSize);
return true;
}
/*----------------------------------------------------------------------------*/
int Threshold::DivideState (int index)
{
SegmentState *new_segment = NULL;
// min value of No.index : not changed
// max value of No.index : changed to (min + max) / 2 of old No.index
// min value of No.index+1 : changed to (min + max) / 2 of old No.index
// max value of No.index+1 : changed to max of old No.index
for (int dim=0; dim<dimension; dim++) {
double new_thre_value = (segment_seq[index].MinValue(dim) + segment_seq[index].MaxValue(dim)) / 2;
if (debug) tl_message ("new_thre_value = %g (%g + %g)/2", new_thre_value, segment_seq[index].MinValue(dim), segment_seq[index].MaxValue(dim));
new_segment = new SegmentState (new_thre_value, segment_seq[index].MaxValue(dim));
segment_seq[index].SetMaxValue(dim, new_thre_value);
InsertSegment (index, new_segment);
}
number_of_state++;
return TRUE;
}
nsresult sbSeekableChannel::ReadSegment(
nsIInputStream *pStream,
PRUint32 numBytes)
{
Segment *pSegment = NULL;
char *buffer = NULL;
PRUint64 readOffset = mBasePos;
PRUint32 bytesRead;
nsresult result = NS_OK;
/* Allocate a data segment buffer. */
buffer = (char *) nsMemory::Alloc(numBytes);
if (!buffer)
result = NS_ERROR_OUT_OF_MEMORY;
/* Read data from the stream. */
if (NS_SUCCEEDED(result))
{
result = pStream->Read(buffer, numBytes, &bytesRead);
if (NS_SUCCEEDED(result))
{
mBasePos += bytesRead;
if (mBasePos > mContentLength)
mContentLength = mBasePos;
}
}
/* Create a new data segment buffer. */
if (NS_SUCCEEDED(result))
{
pSegment = new Segment();
if (pSegment)
{
pSegment->offset = readOffset;
pSegment->length = bytesRead;
pSegment->buffer = buffer;
buffer = NULL;
}
else
{
result = NS_ERROR_UNEXPECTED;
}
}
/* Insert the segment into the channel data set. */
if (NS_SUCCEEDED(result))
result = InsertSegment(pSegment);
if (NS_SUCCEEDED(result))
pSegment = NULL;
/* Channel reading is complete if an error occured */
/* or if all of the channel data has been read. */
if (NS_FAILED(result) || AllDataRead())
mCompleted = PR_TRUE;
/* Clean up on error. */
if (!NS_SUCCEEDED(result))
{
if (pSegment)
delete (pSegment);
if (buffer)
nsMemory::Free(buffer);
}
return (result);
}
