// JLH = James L. Hammons <jlhamm@acm.org>
//
// Who When What
-// --- ---------- ------------------------------------------------------------
+// --- ---------- -----------------------------------------------------------
// JLH ??/??/200? Created this file
// JLH 05/18/2004 Added pure point adding, inserting, better polygon handling
//
}*/
GlyphPoints::GlyphPoints(int nPts/*=0*/, int nPlys/*=0*/, int * xa/*=null*/, int * ya/*=null*/,
- bool * oca/*=null*/, uint16 * pa/*=null*/): x(NULL), y(NULL), onCurve(NULL), polyEnd(NULL)
+ bool * oca/*=null*/, uint16_t * pa/*=null*/): x(NULL), y(NULL), onCurve(NULL), polyEnd(NULL)
//GlyphPoints::GlyphPoints(int nPts, int nPlys/*=0*/, int * xa/*=null*/, int * ya/*=null*/,
-// bool * oca/*=null*/, uint16 * pa/*=null*/): x(NULL), y(NULL), onCurve(NULL), polyEnd(NULL)
+// bool * oca/*=null*/, uint16_t * pa/*=null*/): x(NULL), y(NULL), onCurve(NULL), polyEnd(NULL)
{
AllocateAndCopy(nPts, nPlys, xa, ya, oca, pa);
if (nPlys == 0)
{
numPolys = 1;
- polyEnd = new uint16[numPolys];
+ polyEnd = new uint16_t[numPolys];
polyEnd[0] = numPoints - 1;
}
#ifdef DEBUG
}
-void GlyphPoints::AllocateAndCopy(int nPts, int nPlys, int * xa, int * ya, bool * oca, uint16 * pa)
+void GlyphPoints::AllocateAndCopy(int nPts, int nPlys, int * xa, int * ya, bool * oca, uint16_t * pa)
{
numPoints = nPts, numPolys = nPlys;
if (numPolys)
{
- polyEnd = new uint16[numPolys];
+ polyEnd = new uint16_t[numPolys];
if (pa) // Copy poly ends in if they're passed in...
for(int i=0; i<nPlys; i++)
if (this == &c)
return *this; // Take care of self-assignment
-#if 0
- if (x)
- delete[] x;
-
- if (y)
- delete[] y;
-
- if (onCurve)
- delete[] onCurve;
-
- if (polyEnd)
- delete[] polyEnd;
-#endif
FreeAllocatedMemory();
AllocateAndCopy(c.numPoints, c.numPolys, c.x, c.y, c.onCurve, c.polyEnd);
int * totX = new int[totPoints];
int * totY = new int[totPoints];
bool * totOnCurve = new bool[totPoints];
- uint16 * totPolyEnd = new uint16[totPolys];
+ uint16_t * totPolyEnd = new uint16_t[totPolys];
for(int i=0; i<numPoints; i++)
{
int * totX = new int[numPoints + 1];
int * totY = new int[numPoints + 1];
bool * totOnCurve = new bool[numPoints + 1];
- uint16 * totPolyEnd = new uint16[numPolys];
+ uint16_t * totPolyEnd = new uint16_t[numPolys];
for(int i=0; i<numPoints; i++)
totX[i] = x[i], totY[i] = y[i], totOnCurve[i] = onCurve[i];
onCurve = NULL;
polyEnd = NULL;
numPoints = numPolys = pointsAllocated = polysAllocated = 0;
+
+ numPolys = 1;
+ polyEnd = new uint16_t[numPolys];
+ polyEnd[0] = numPoints - 1;
}
-void GlyphPoints::InsertPoint(uint16 pt, int xx, int yy, bool oc)
+void GlyphPoints::InsertPoint(uint16_t pt, int xx, int yy, bool oc)
{
+//wouldn't it be better to treat this case as inserting at the end?
if (pt > numPoints) // > because we can insert at end...!
throw GP_OUT_OF_RANGE;
//we're adding to the end of the structure: [DONE, below]
int polyInsert = (pt == numPoints ? numPolys - 1 : GetPoly(pt));
for(int i=polyInsert; i<numPolys; i++)
-// for(int i=GetPoly(pt); i<numPolys; i++)
polyEnd[i]++; // Bump polygons' end point
numPoints++;
}
-void GlyphPoints::InsertPoint(uint16 pt, const IPoint &p)
+void GlyphPoints::InsertPoint(uint16_t pt, const IPoint &p)
{
InsertPoint(pt, p.x, p.y, p.onCurve);
}
// size counters down as needed. In the future, we'll keep track so we
// don't have to reallocate *every* damn time a point is added...
//
-void GlyphPoints::DeletePoint(uint16 pt)
+void GlyphPoints::DeletePoint(uint16_t pt)
{
// Adjust polygon ends appropriately
- uint16 poly = GetPoly(pt);
+ uint16_t poly = GetPoly(pt);
for(int i=poly; i<numPolys; i++)
polyEnd[i]--;
}
-uint16 GlyphPoints::GetNumPoints(void)
+uint16_t GlyphPoints::GetNumPoints(void)
{
return numPoints;
}
-uint16 GlyphPoints::GetNumPoints(uint16 poly)
+uint16_t GlyphPoints::GetNumPoints(uint16_t poly)
{
if (poly >= numPolys)
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetNumPoints(uint16). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
+WriteLogMsg("Exception: GetNumPoints(uint16_t). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
-uint16 GlyphPoints::GetNumPolys(void)
+uint16_t GlyphPoints::GetNumPolys(void)
{
return numPolys;
}
-int GlyphPoints::GetX(uint16 pt)
+int GlyphPoints::GetX(uint16_t pt)
{
if (pt >= numPoints)
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetX(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: GetX(uint16_t). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
-int GlyphPoints::GetY(uint16 pt)
+int GlyphPoints::GetY(uint16_t pt)
{
if (pt >= numPoints)
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetY(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: GetY(uint16_t). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
-bool GlyphPoints::GetOnCurve(uint16 pt)
+Vector GlyphPoints::GetXY(uint16_t pt)
{
if (pt >= numPoints)
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetOnCurve(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: GetXY(uint16_t). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+#endif
+ throw GP_OUT_OF_RANGE;
+#ifdef DEBUG
+}
+#endif
+
+ return Vector(x[pt], y[pt]);
+}
+
+
+bool GlyphPoints::GetOnCurve(uint16_t pt)
+{
+ if (pt >= numPoints)
+#ifdef DEBUG
+{
+WriteLogMsg("Exception: GetOnCurve(uint16_t). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
-int GlyphPoints::GetX(uint16 poly, uint16 pt)
+int GlyphPoints::GetX(uint16_t poly, uint16_t pt)
{
if (pt >= GetNumPoints(poly))
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetX(uint16, uint16). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
+WriteLogMsg("Exception: GetX(uint16_t, uint16_t). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
-int GlyphPoints::GetNextX(uint16 poly, uint16 pt)
+int GlyphPoints::GetNextX(uint16_t poly, uint16_t pt)
{
return GetX(poly, GetNext(poly, pt));
}
-int GlyphPoints::GetY(uint16 poly, uint16 pt)
+int GlyphPoints::GetY(uint16_t poly, uint16_t pt)
{
if (pt >= GetNumPoints(poly))
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetY(uint16, uint16). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
+WriteLogMsg("Exception: GetY(uint16_t, uint16_t). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
-int GlyphPoints::GetNextY(uint16 poly, uint16 pt)
+int GlyphPoints::GetNextY(uint16_t poly, uint16_t pt)
{
return GetY(poly, GetNext(poly, pt));
}
-IPoint GlyphPoints::GetPoint(uint16 poly, uint16 pt)
+IPoint GlyphPoints::GetPoint(uint16_t poly, uint16_t pt)
+{
+ return IPoint(GetX(poly, pt), GetY(poly, pt), GetOnCurve(poly, pt));
+}
+
+
+IPoint GlyphPoints::GetPoint(uint16_t pointNumber)
{
- return IPoint(GetX(poly, pt), GetY(poly, pt));
+ if (pointNumber > numPoints)
+ throw GP_OUT_OF_RANGE;
+
+ return IPoint(x[pointNumber], y[pointNumber], onCurve[pointNumber]);
}
-bool GlyphPoints::GetOnCurve(uint16 poly, uint16 pt)
+bool GlyphPoints::GetOnCurve(uint16_t poly, uint16_t pt)
{
if (pt >= GetNumPoints(poly))
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetOnCurve(uint16, uint16). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
+WriteLogMsg("Exception: GetOnCurve(uint16_t, uint16_t). poly= %u, pt=%u, numPoints=%u\xD\xA", poly, pt, numPoints);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
-bool GlyphPoints::GetPrevOnCurve(uint16 poly, uint16 pt)
+bool GlyphPoints::GetPrevOnCurve(uint16_t poly, uint16_t pt)
{
return GetOnCurve(poly, GetPrev(poly, pt));
}
-bool GlyphPoints::GetNextOnCurve(uint16 poly, uint16 pt)
+bool GlyphPoints::GetNextOnCurve(uint16_t poly, uint16_t pt)
{
return GetOnCurve(poly, GetNext(poly, pt));
}
-uint16 GlyphPoints::GetPolyStart(uint16 poly)
+uint16_t GlyphPoints::GetPolyStart(uint16_t poly)
{
if (poly >= numPolys)
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetPolyEnd(uint16). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
+WriteLogMsg("Exception: GetPolyEnd(uint16_t). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
-uint16 GlyphPoints::GetPolyEnd(uint16 poly)
+uint16_t GlyphPoints::GetPolyEnd(uint16_t poly)
{
if (poly >= numPolys)
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetPolyEnd(uint16). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
+WriteLogMsg("Exception: GetPolyEnd(uint16_t). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
//
// Offset only a specific polygon in the glyph
//
-void GlyphPoints::OffsetPoly(uint16 poly, int32 xOff, int32 yOff)
+void GlyphPoints::OffsetPoly(uint16_t poly, int32_t xOff, int32_t yOff)
{
if (poly >= numPolys)
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetPolyEnd(uint16). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
+WriteLogMsg("Exception: GetPolyEnd(uint16_t). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
#endif
- uint16 polyStart = (poly == 0 ? 0 : polyEnd[poly - 1] + 1);
+ uint16_t polyStart = (poly == 0 ? 0 : polyEnd[poly - 1] + 1);
for(int i=0; i<GetNumPoints(poly); i++)
x[polyStart + i] += xOff, y[polyStart + i] += yOff;
}
-void GlyphPoints::SetXY(uint16 pt, int xx, int yy)
+void GlyphPoints::SetXY(uint16_t pt, int xx, int yy)
{
if (pt >= numPoints)
#ifdef DEBUG
{
-WriteLogMsg("Exception: SetXY(uint16, int, int). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: SetXY(uint16_t, int, int). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
-void GlyphPoints::SetOnCurve(uint16 pt, bool oc)
+void GlyphPoints::SetOnCurve(uint16_t pt, bool oc)
{
if (pt >= numPoints)
#ifdef DEBUG
{
-WriteLogMsg("Exception: SetOnCurve(uint16, bool). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: SetOnCurve(uint16_t, bool). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
}
-uint16 GlyphPoints::GetPrev(uint16 pt)
+void GlyphPoints::SetPoint(const uint16_t pointNum, const IPoint point)
+{
+ if (pointNum >= numPoints)
+#ifdef DEBUG
+{
+WriteLogMsg("Exception: SetPoint(uint16_t, IPoint). pt=%u, numPoints=%u\xD\xA", pointNum, numPoints);
+#endif
+ throw GP_OUT_OF_RANGE;
+#ifdef DEBUG
+}
+#endif
+
+ x[pointNum] = point.x, y[pointNum] = point.y, onCurve[pointNum] = point.onCurve;
+}
+
+
+uint16_t GlyphPoints::GetPrev(uint16_t pt)
{
// pt = 7, polyEnd = 4, 9, 15
- uint16 min = 0, max = numPoints - 1;
+ uint16_t min = 0, max = numPoints - 1;
for(int i=0; i<numPolys; i++)
{
}
}
- uint16 retVal = pt - 1;
+ uint16_t retVal = pt - 1;
if (pt == min)
retVal = max;
}
-uint16 GlyphPoints::GetNext(uint16 pt)
+uint16_t GlyphPoints::GetNext(uint16_t pt)
{
- uint16 min = 0, max = numPoints - 1;
+ uint16_t min = 0, max = numPoints - 1;
for(int i=0; i<numPolys; i++)
{
}
}
- uint16 retVal = pt + 1;
+ uint16_t retVal = pt + 1;
if (pt == max)
retVal = min;
// Get previous point for this polygon using wraparound.
// Note that pt is a zero-based index!
//
-uint16 GlyphPoints::GetPrev(uint16 poly, uint16 pt)
+uint16_t GlyphPoints::GetPrev(uint16_t poly, uint16_t pt)
{
return (pt == 0 ? GetNumPoints(poly) - 1 : pt - 1);
}
// Get next point for this polygon using wraparound.
// Note that pt is a zero-based index!
//
-uint16 GlyphPoints::GetNext(uint16 poly, uint16 pt)
+uint16_t GlyphPoints::GetNext(uint16_t poly, uint16_t pt)
{
return (pt == GetNumPoints(poly) - 1 ? 0 : pt + 1);
}
-uint16 GlyphPoints::GetPoly(uint16 pt)
+#warning "!!! This function returns incorrect results !!!"
+uint16_t GlyphPoints::GetPoly(uint16_t pt)
{
if (pt >= numPoints)
#ifdef DEBUG
{
-WriteLogMsg("Exception: GetPoly(uint16). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
+WriteLogMsg("Exception: GetPoly(uint16_t). pt=%u, numPoints=%u\xD\xA", pt, numPoints);
#endif
throw GP_OUT_OF_RANGE;
#ifdef DEBUG
if (pt <= polyEnd[i])
return i;
- return (uint16)-1;
+ return (uint16_t)-1;
}
if (numPoints == 0) // By default, we already *have* a poly
return;
- uint16 * newPolyEnd = new uint16[numPolys + 1];
+ uint16_t * newPolyEnd = new uint16_t[numPolys + 1];
- for(uint16 i=0; i<numPolys; i++)
+ for(uint16_t i=0; i<numPolys; i++)
newPolyEnd[i] = polyEnd[i];
newPolyEnd[numPolys] = newPolyEnd[numPolys - 1];
}
-IPoint GlyphPoints::GetMidpointToPrev(uint16 poly, uint16 pt)
+IPoint GlyphPoints::GetMidpointToPrev(uint16_t poly, uint16_t pt)
{
- uint16 prev = GetPrev(poly, pt);
+ uint16_t prev = GetPrev(poly, pt);
- int32 x1 = GetX(poly, pt), y1 = GetY(poly, pt);
- int32 x2 = GetX(poly, prev), y2 = GetY(poly, prev);
+ int32_t x1 = GetX(poly, pt), y1 = GetY(poly, pt);
+ int32_t x2 = GetX(poly, prev), y2 = GetY(poly, prev);
return IPoint((x1 + x2) / 2.0f, (y1 + y2) / 2.0f);
}
-IPoint GlyphPoints::GetMidpointToNext(uint16 poly, uint16 pt)
+IPoint GlyphPoints::GetMidpointToNext(uint16_t poly, uint16_t pt)
{
- uint16 next = GetNext(poly, pt);
+ uint16_t next = GetNext(poly, pt);
- int32 x1 = GetX(poly, pt), y1 = GetY(poly, pt);
- int32 x2 = GetX(poly, next), y2 = GetY(poly, next);
+ int32_t x1 = GetX(poly, pt), y1 = GetY(poly, pt);
+ int32_t x2 = GetX(poly, next), y2 = GetY(poly, next);
return IPoint((x1 + x2) / 2.0f, (y1 + y2) / 2.0f);
}
-IPoint GlyphPoints::GetPrevPoint(uint16 poly, uint16 pt)
+IPoint GlyphPoints::GetPrevPoint(uint16_t poly, uint16_t pt)
{
- uint16 prevPt = GetPrev(poly, pt);
+ uint16_t prevPt = GetPrev(poly, pt);
return IPoint(GetX(poly, prevPt), GetY(poly, prevPt));
}
-IPoint GlyphPoints::GetNextPoint(uint16 poly, uint16 pt)
+IPoint GlyphPoints::GetNextPoint(uint16_t poly, uint16_t pt)
{
- uint16 nextPt = GetNext(poly, pt);
+ uint16_t nextPt = GetNext(poly, pt);
return IPoint(GetX(poly, nextPt), GetY(poly, nextPt));
}
+uint16_t GlyphPoints::GetPolyForPoint(IPoint point)
+{
+ uint16_t poly = 0;
+
+ for(uint16_t i=0; i<numPoints; i++)
+ {
+ if (i > polyEnd[poly])
+ poly++;
+
+ if (IPoint(x[i], y[i]) == point)
+ return poly;
+ }
+
+ return 0xFFFF;
+}
+
+
+uint16_t GlyphPoints::GetPolyForPointNumber(uint16_t pointNumber)
+{
+ // If there's only one poly, we know where the point is...
+ if (numPolys <= 1)
+ return 0;
+
+ // Otherwise, do a linear search through the polys to find the right one
+ for(uint16_t i=0; i<numPolys; i++)
+ {
+ if (pointNumber >= GetPolyStart(i) && pointNumber <= polyEnd[i])
+ return i;
+ }
+
+ return 0xFFFF;
+}
+
+
//
// Rotate a point by "angle" around point "center"
//
}
-IPoint GlyphPoints::GetPolyCentroid(const int16 poly)
+IPoint GlyphPoints::GetPolyCentroid(const int16_t poly)
{
// We should throw an exception here, but meh
// (this actually short circuits the exception handling in all the GetPolyXXX() functions)
+ // [now we do!]
if (poly >= numPolys)
- return IPoint(0, 0);
+ throw GP_OUT_OF_RANGE;
+// return IPoint(0, 0);
// if (poly >= numPolys)
//#ifdef DEBUG
//{
-//WriteLogMsg("Exception: GetPolyEnd(uint16). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
+//WriteLogMsg("Exception: GetPolyEnd(uint16_t). poly=%u, numPolys=%u\xD\xA", poly, numPolys);
//#endif
// throw GP_OUT_OF_RANGE;
//#ifdef DEBUG
//#endif
IPoint centroid; // Initializes to (0, 0)
- uint16 numPointsInPoly = GetNumPoints(poly);
+ uint16_t numPointsInPoly = GetNumPoints(poly);
- for(uint16 i=GetPolyStart(poly); i<=GetPolyEnd(poly); i++)
+ for(uint16_t i=GetPolyStart(poly); i<=GetPolyEnd(poly); i++)
{
centroid.x += x[i];
centroid.y += y[i];
}
-void GlyphPoints::RotatePolyAroundCentroid(const int16 poly, const double angle)
+void GlyphPoints::RotatePolyAroundCentroid(const int16_t poly, const double angle)
{
if (poly >= numPolys)
return;
IPoint centroid = GetPolyCentroid(poly);
- for(uint16 i=GetPolyStart(poly); i<=GetPolyEnd(poly); i++)
+ for(uint16_t i=GetPolyStart(poly); i<=GetPolyEnd(poly); i++)
{
IPoint rotated = RotatePoint(angle, IPoint(x[i], y[i]), centroid);
x[i] = rotated.x;
}
+void GlyphPoints::InvertPolyDrawSequence(const uint16_t poly)
+{
+ if (poly >= numPolys)
+ throw GP_OUT_OF_RANGE;
+
+ uint16_t pointNum1 = GetPolyStart(poly);
+ uint16_t pointNum2 = GetPolyEnd(poly);
+
+ // Algorithm: Step through points in the polygon, swapping 1st and last, then
+ // 2nd and (last - 1), 3rd and (last - 2), etc. We only do this for half the
+ // points, as doing it for all would undo the swapping we did in the 1st half.
+ for(uint16_t i=0; i<GetNumPoints(poly)/2; i++)
+ {
+ IPoint point1 = GetPoint(pointNum1 + i);
+ IPoint point2 = GetPoint(pointNum2 - i);
+ SetPoint(pointNum2 - i, point1);
+ SetPoint(pointNum1 + i, point2);
+ }
+}
+
+
// really need to do checking on the results from fscanf...
bool GlyphPoints::LoadGlyphFromFile(FILE * file)
{
for(int i=0; i<numPoints; i++)
{
- fscanf(file, "%d %d %s", &x[i], &y[i], &line);
+ fscanf(file, "%d %d %s", &x[i], &y[i], (char *)&line);
onCurve[i] = (line[0] == 'T' ? true : false);
}
fscanf(file, "%s %u", line, &numPolys);
- polyEnd = new uint16[numPolys];
+ polyEnd = new uint16_t[numPolys];
for(int i=0; i<numPolys; i++)
{
projects / ttedit / blobdiff