X-Git-Url: https://git.ucc.asn.au/?p=ipdf%2Fcode.git;a=blobdiff_plain;f=src%2Fdocument.cpp;h=7c490742086327484c26a5b4bbe0b9d39dc7ba04;hp=d745c1548f9818461c15ff8bf75117670991f1c2;hb=7a83af96414ff156f56455ff7a5e7af01fc403b5;hpb=0d33eac5144178de754ad9f53e39463f79a31398 diff --git a/src/document.cpp b/src/document.cpp index d745c15..7c49074 100644 --- a/src/document.cpp +++ b/src/document.cpp @@ -1,10 +1,13 @@ #include "document.h" - +#include "bezier.h" #include +#include using namespace IPDF; using namespace std; +//TODO: Make this work for variable sized Reals + // Loads an std::vector of size num_elements from a file. template static void LoadStructVector(FILE *src_file, size_t num_elems, std::vector& dest) @@ -26,6 +29,26 @@ static void SaveStructVector(FILE *dst_file, std::vector& src) Fatal("Only wrote %u structs (expected %u)!", written, src.size()); } +static void WriteChunkHeader(FILE *dst_file, DocChunkTypes type, uint32_t size) +{ + size_t written = 0; + written = fwrite(&type, sizeof(type), 1, dst_file); + if (written != 1) + Fatal("Could not write Chunk header! (ID)"); + written = fwrite(&size, sizeof(size), 1, dst_file); + if (written != 1) + Fatal("Could not write Chunk header (size)!"); +} + +static bool ReadChunkHeader(FILE *src_file, DocChunkTypes& type, uint32_t& size) +{ + if (fread(&type, sizeof(DocChunkTypes), 1, src_file) != 1) + return false; + if (fread(&size, sizeof(uint32_t), 1, src_file) != 1) + return false; + return true; +} + void Document::Save(const string & filename) { Debug("Saving document to file \"%s\"...", filename.c_str()); @@ -35,16 +58,27 @@ void Document::Save(const string & filename) size_t written; Debug("Number of objects (%u)...", ObjectCount()); + WriteChunkHeader(file, CT_NUMOBJS, sizeof(m_count)); written = fwrite(&m_count, sizeof(m_count), 1, file); if (written != 1) Fatal("Failed to write number of objects!"); Debug("Object types..."); + WriteChunkHeader(file, CT_OBJTYPES, m_objects.types.size() * sizeof(ObjectType)); SaveStructVector(file, m_objects.types); Debug("Object bounds..."); + WriteChunkHeader(file, CT_OBJBOUNDS, m_objects.bounds.size() * sizeof(Rect)); SaveStructVector(file, m_objects.bounds); + Debug("Object data indices..."); + WriteChunkHeader(file, CT_OBJINDICES, m_objects.data_indices.size() * sizeof(unsigned)); + SaveStructVector(file, m_objects.data_indices); + + Debug("Bezier data..."); + WriteChunkHeader(file, CT_OBJBEZIERS, m_objects.beziers.size() * sizeof(uint8_t)); + SaveStructVector(file, m_objects.beziers); + int err = fclose(file); if (err != 0) Fatal("Failed to close file \"%s\" - %s", filename.c_str(), strerror(err)); @@ -52,6 +86,54 @@ void Document::Save(const string & filename) Debug("Successfully saved %u objects to \"%s\"", ObjectCount(), filename.c_str()); } +#ifndef QUADTREE_DISABLED + +void Document::GenBaseQuadtree() +{ + m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QTC_UNKNOWN, 0, ObjectCount()}); + m_quadtree.root_id = 0; + GenQuadNode(0, QTC_TOP_LEFT); +} + +QuadTreeIndex Document::GenQuadNode(QuadTreeIndex parent, QuadTreeNodeChildren type) +{ + QuadTreeIndex new_index = m_quadtree.nodes.size(); + m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, parent, type, 0, 0}); + + m_quadtree.nodes[new_index].object_begin = m_objects.bounds.size(); + for (unsigned i = m_quadtree.nodes[parent].object_begin; i < m_quadtree.nodes[parent].object_end; ++i) + { + if (ContainedInQuadChild(m_objects.bounds[i], type)) + { + m_objects.bounds.push_back(TransformToQuadChild(m_objects.bounds[i], type)); + m_objects.types.push_back(m_objects.types[i]); + m_objects.data_indices.push_back(m_objects.data_indices[i]); + m_count++; + } + } + m_quadtree.nodes[new_index].object_end = m_objects.bounds.size(); + switch (type) + { + case QTC_TOP_LEFT: + m_quadtree.nodes[parent].top_left = new_index; + break; + case QTC_TOP_RIGHT: + m_quadtree.nodes[parent].top_right = new_index; + break; + case QTC_BOTTOM_LEFT: + m_quadtree.nodes[parent].bottom_left = new_index; + break; + case QTC_BOTTOM_RIGHT: + m_quadtree.nodes[parent].bottom_right = new_index; + break; + default: + Fatal("Tried to add a QuadTree child of invalid type!"); + } + return new_index; +} + +#endif + void Document::Load(const string & filename) { m_objects.bounds.clear(); @@ -67,27 +149,61 @@ void Document::Load(const string & filename) Fatal("Couldn't open file \"%s\"", filename.c_str(), strerror(errno)); size_t read; - read = fread(&m_count, sizeof(m_count), 1, file); - if (read != 1) - Fatal("Failed to read number of objects!"); - Debug("Number of objects: %u", ObjectCount()); - Debug("Object types..."); - LoadStructVector(file, ObjectCount(), m_objects.types); - - Debug("Object bounds..."); - LoadStructVector(file, ObjectCount(), m_objects.bounds); - + DocChunkTypes chunk_type; + uint32_t chunk_size; + while (ReadChunkHeader(file, chunk_type, chunk_size)) + { + switch(chunk_type) + { + case CT_NUMOBJS: + read = fread(&m_count, sizeof(m_count), 1, file); + if (read != 1) + Fatal("Failed to read number of objects!"); + Debug("Number of objects: %u", ObjectCount()); + break; + case CT_OBJTYPES: + Debug("Object types..."); + LoadStructVector(file, chunk_size/sizeof(ObjectType), m_objects.types); + break; + case CT_OBJBOUNDS: + Debug("Object bounds..."); + LoadStructVector(file, chunk_size/sizeof(Rect), m_objects.bounds); + break; + case CT_OBJINDICES: + Debug("Object data indices..."); + LoadStructVector(file, chunk_size/sizeof(unsigned), m_objects.data_indices); + break; + case CT_OBJBEZIERS: + Debug("Bezier data..."); + LoadStructVector(file, chunk_size/sizeof(Bezier), m_objects.beziers); + break; + } + } Debug("Successfully loaded %u objects from \"%s\"", ObjectCount(), filename.c_str()); +#ifndef QUADTREE_DISABLED + if (m_quadtree.root_id == QUADTREE_EMPTY) + { + GenBaseQuadtree(); + } +#endif } -void Document::Add(ObjectType type, const Rect & bounds) +void Document::Add(ObjectType type, const Rect & bounds, unsigned data_index) { m_objects.types.push_back(type); m_objects.bounds.push_back(bounds); - m_count++; + m_objects.data_indices.push_back(data_index); + ++m_count; // Why can't we just use the size of types or something? +} + +unsigned Document::AddBezierData(const Bezier & bezier) +{ + m_objects.beziers.push_back(bezier); + return m_objects.beziers.size()-1; } + void Document::DebugDumpObjects() { Debug("Objects for Document %p are:", this); @@ -99,5 +215,223 @@ void Document::DebugDumpObjects() bool Document::operator==(const Document & equ) const { - return (ObjectCount() == equ.ObjectCount() && memcmp(m_objects.bounds.data(), equ.m_objects.bounds.data(), ObjectCount() * sizeof(Rect)) == 0); + return (ObjectCount() == equ.ObjectCount() + && memcmp(m_objects.bounds.data(), equ.m_objects.bounds.data(), ObjectCount() * sizeof(Rect)) == 0 + && memcmp(m_objects.data_indices.data(), equ.m_objects.data_indices.data(), ObjectCount() * sizeof(unsigned)) == 0 + && memcmp(m_objects.beziers.data(), equ.m_objects.beziers.data(), m_objects.beziers.size() * sizeof(Bezier)) == 0); +} + + +#include "../contrib/pugixml-1.4/src/pugixml.hpp" +#include "../contrib/pugixml-1.4/src/pugixml.cpp" + +void Document::LoadSVG(const string & filename, const Rect & bounds) +{ + using namespace pugi; + + xml_document doc_xml; + ifstream input(filename.c_str(), ios_base::in); + xml_parse_result result = doc_xml.load(input); + + if (!result) + Fatal("Couldn't load \"%s\" - %s", filename.c_str(), result.description()); + + Debug("Loaded XML - %s", result.description()); + + input.close(); + + // Combine all SVG tags into one thing because lazy + for (xml_node svg : doc_xml.children("svg")) + { + Real width = svg.attribute("width").as_float() * bounds.w; + Real height = svg.attribute("width").as_float() * bounds.h; + + + // Rectangles + Real coords[4]; + const char * attrib_names[] = {"x", "y", "width", "height"}; + for (pugi::xml_node rect : svg.children("rect")) + { + for (size_t i = 0; i < 4; ++i) + coords[i] = rect.attribute(attrib_names[i]).as_float(); + + bool outline = !(rect.attribute("fill")); + Add(outline?RECT_OUTLINE:RECT_FILLED, Rect(coords[0]/width + bounds.x, coords[1]/height + bounds.y, coords[2]/width, coords[3]/height),0); + Debug("Added rectangle"); + } + + // Circles + for (pugi::xml_node circle : svg.children("circle")) + { + Real cx = circle.attribute("cx").as_float(); + Real cy = circle.attribute("cy").as_float(); + Real r = circle.attribute("r").as_float(); + + Real x = (cx - r)/width + bounds.x; + Real y = (cy - r)/height + bounds.y; + Real w = 2*r/width; + Real h = 2*r/height; + + Rect rect(x,y,w,h); + Add(CIRCLE_FILLED, rect,0); + Debug("Added Circle %s", rect.Str().c_str()); + + } + + // paths + for (pugi::xml_node path : svg.children("path")) + { + + string d = path.attribute("d").as_string(); + Debug("Path data attribute is \"%s\"", d.c_str()); + AddPathFromString(d, Rect(bounds.x,bounds.y,width,height)); + + } + } + + //Fatal("Done"); + + + +} + +// Behold my amazing tokenizing abilities +static string & GetToken(const string & d, string & token, unsigned & i) +{ + token.clear(); + while (i < d.size() && iswspace(d[i])) + { + ++i; + } + + while (i < d.size()) + { + if (d[i] == ',' || isalpha(d[i]) || iswspace(d[i])) + { + if (token.size() == 0 && !iswspace(d[i])) + { + token += d[i++]; + } + break; + } + token += d[i++]; + } + Debug("Got token \"%s\"", token.c_str()); + return token; +} + + +// Fear the wrath of the tokenizing svg data +// Seriously this isn't really very DOM-like at all is it? +void Document::AddPathFromString(const string & d, const Rect & bounds) +{ + Real x[3] = {0,0,0}; + Real y[3] = {0,0,0}; + + string token(""); + string command("m"); + + unsigned i = 0; + unsigned prev_i = 0; + Real x0; + Real y0; + bool started = false; + while (i < d.size() && GetToken(d, token, i).size() > 0) + { + if (isalpha(token[0])) + command = token; + else + { + i = prev_i; // hax + if(command == "") + command = "l"; + } + + if (command == "m") + { + Debug("Construct moveto command"); + x[0] = strtod(GetToken(d,token,i).c_str(),NULL) / bounds.w; + assert(GetToken(d,token,i) == ","); + y[0] = strtod(GetToken(d,token,i).c_str(),NULL) / bounds.h; + if (!started) + { + x0 = x[0]; + y0 = y[0]; + started = true; + } + Debug("mmoveto %f,%f", Float(x[0]),Float(y[0])); + command = "l"; + } + else if (command == "c") + { + Debug("Construct curveto command"); + x[0] = strtod(GetToken(d,token,i).c_str(),NULL)/bounds.w; + assert(GetToken(d,token,i) == ","); + y[0] = strtod(GetToken(d,token,i).c_str(),NULL)/bounds.h; + + x[1] = strtod(GetToken(d,token,i).c_str(),NULL) / bounds.w; + assert(GetToken(d,token,i) == ","); + y[1] = strtod(GetToken(d,token,i).c_str(),NULL) / bounds.h; + + x[2] = strtod(GetToken(d,token,i).c_str(),NULL) / bounds.w; + assert(GetToken(d,token,i) == ","); + y[2] = strtod(GetToken(d,token,i).c_str(),NULL) / bounds.h; + + unsigned index = AddBezierData(Bezier(x[0],y[0],x[1],y[1],x[2],y[2])); + Add(BEZIER,bounds,index); + + + Debug("[%u] curveto %f,%f %f,%f %f,%f", index, Float(x[0]),Float(y[0]),Float(x[1]),Float(y[1]),Float(x[2]),Float(y[2])); + + x[0] = x[2]; + y[0] = y[2]; + + + } + else if (command == "l") + { + Debug("Construct lineto command"); + + x[1] = strtod(GetToken(d,token,i).c_str(),NULL) / bounds.w; + assert(GetToken(d,token,i) == ","); + y[1] = strtod(GetToken(d,token,i).c_str(),NULL) / bounds.h; + + x[2] = x[1]; + y[2] = y[1]; + + Rect segment_bounds(x[0], y[0], x[2] - x[0], y[2] - y[0]); + + unsigned index = AddBezierData(Bezier(x[0],y[0],x[1],y[1],x[2],y[2])); + Add(BEZIER,bounds,index); + + Debug("[%u] lineto %f,%f %f,%f", index, Float(x[0]),Float(y[0]),Float(x[1]),Float(y[1])); + + x[0] = x[2]; + y[0] = y[2]; + + } + else if (command == "z") + { + Debug("Construct returnto command"); + x[1] = x0; + y[1] = y0; + x[2] = x0; + y[2] = y0; + + unsigned index = AddBezierData(Bezier(x[0],y[0],x[1],y[1],x[2],y[2])); + Add(BEZIER,bounds,index); + + Debug("[%u] returnto %f,%f %f,%f", index, Float(x[0]),Float(y[0]),Float(x[1]),Float(y[1])); + + x[0] = x[2]; + y[0] = y[2]; + command = "m"; + } + else + { + Warn("Unrecognised command \"%s\", set to \"m\"", command.c_str()); + command = "m"; + } + prev_i = i; + } }