Wired2Code

DrawGin, 06.01.2011 status

Paul — Wed, 01 Jun 2011 08:36:26 +0000

The DrawGin library is rapidly taking shape and able to read most sections of an AutoCAD R14 formatted drawing. The next section to code up is the area where AcDbObject and AcDbEntity derived objects are stored (section 6 below). For the purpose of deserializing the bit encoded drawing data, sections 1, 2, 3, 4, 5 are completed.

Drawing File Header – Defines where key sections are located within the drawing file.
Preview Image – Bitmap image created when drawing was last saved.
Header Variables – various setting variables associated with the drawing file.
Classes Map – Holds information about various application defined classes that are used (instances of) in the drawing.
Objects Map – Tells the file position of each object stored in the drawing (with AutoCAD object handle)
Objects – The object instances referenced in the Objects Map (these are AcDbObject and AcDbEntity derived).

Most of the drawing format is defined at the bit level, which require special IO routines found in the OcBs directory (OcBitStream). The OcBsStreamIn class handles reading the various bit level data types and keeps track of the running CRC calculation. The stream also has a 4K memory buffer and handles huge 100 meg files, no problem.

Class DwgArchiveIn (will be renamed later to OcBsDwgArchive) is an archive class that will work much like MFC’s CArchive.

Classes in the OcDb represent the various data types that make up a drawing. Most of the classes will have a one-to-one similarity by name to those found in Autodesk’s ObjectARX SDK. At this time DrawGin is not going for ObjectARX compatibility, so member function names and signatures will not be the same.

Future blog entries will delve into the framework and implementation details. For now just wanted to post a quick status update.

DrawGin

Paul — Tue, 17 May 2011 08:33:57 +0000

DrawGin is a new open source project to read and write “.dwg” file formats. Current work is focused on the cross platform C++ framework to support reading drawing files in the AutoCAD R14 format, with write support to follow shortly thereafter.

There is lots of source code to view at the project page, and if you are interested in contributing to DrawGin, let me know. The code currently compiles in OS X and Linux using the Codelite IDE, and in Windows using Visual C++ 2008.

The “.dwg” format specification, versions 4.0 and 5.1, published by the Open Design Alliance are the reference documents used to write the DrawGin library.

Visual C++ Code Formatting with AStyle

Paul — Mon, 24 Jan 2011 06:53:43 +0000

Visual Studio VBA macro to format the current C++/h document using the open source code formatter AStyle. Simply copy the macro to the “Macros->Module1” is Visual Studio, then hookup a hot key to it.

Download AStyle from http://astyle.sourceforge.net/ and extract to a directory (code will look in the download directory off the user’s home directory). Update the shellCmd string variable with any formatting options AStyle should apply (http://astyle.sourceforge.net/astyle.html).

Format string “-A4Uxpfn”
-A4 = stroustrup style
-U = unpad paren
-x = delete empty lines
-p = pad operators
-f = break blocks
-n = do not retain backup

Code Snippet

Public Sub formatDocWithAStyle()
 Dim fileName As String
 Dim textDocument As TextDocument
 Dim startPoint As EnvDTE.EditPoint
 Dim endPoint As EnvDTE.EditPoint
 Dim text As String
 Dim shellCmd As String
 Dim procId As Integer
 If DTE.ActiveDocument Is Nothing Then
 Return
 End If
 fileName = Environ$(“TEMP”) & “\formattedCode”
 shellCmd = “”"” & Environ$(“HOMEPATH”) & “\Downloads\AStyle\bin\AStyle” & “”"” & ” -A4Uxpfn “ & “”"” & fileName & “”"”
 textDocument = DTE.ActiveDocument.Object
 startPoint = textDocument.StartPoint.CreateEditPoint
 endPoint = textDocument.EndPoint.CreateEditPoint
 text = startPoint.GetText(endPoint)
 My.Computer.FileSystem.WriteAllText(fileName, text, False)
 procId = Shell(shellCmd, AppWinStyle.Hide, True, 30000)
 If procId = 0 Then
 text = My.Computer.FileSystem.ReadAllText(fileName)
 startPoint.ReplaceText(endPoint, text, vsEPReplaceTextOptions.vsEPReplaceTextTabsSpaces)
 End If
End Sub

Installing latest gdb on Snow Leopard

Paul — Mon, 11 Oct 2010 23:31:22 +0000

Figures there would be a problem installing gdb on Snow Leopard using Macports. The error message was libbfd.c: In function ‘bfd_get_b_signed_64’: … lipo: can’t figure out the architecture type of: …

Looking at the build log file shows gdb being built for i386 and x86_64. After a little poking around I found the culprit to be in
/opt/local/etc/macports/variants.conf

where when I initially installed Macports had enabled +universal (don’t recall why). So, comment out the +universal line and rebuilt gdb.

sudo port clean gdb
sudo port install gdb

Afterwards, the new gdb will be installed to

/opt/local/bin/fsf-gdb

Installing latest gcc on Snow Leopard

Paul — Mon, 11 Oct 2010 22:45:53 +0000

I decided to install gcc 4.5.1 via Macports and the process didn’t exactly go smoothly. IIRC, the initial error was something about base_file.cc not being find. I’m not sure what caused the problem, however the fix was to temporarily rename the directory /opt/local to /opt/local-temp. The only packages installed in /opt/local/ are python 2.6, git, and Qt4.7.

So the basic steps if you have problems with the install using Macports is
cd /opt mv local local-temp sudo port clean gcc45 sudo port selfupdate sudo port upgrade outdated sudo port install gcc45

Towards the end of the build process there was another error about libpng being wrong or something. Simply reinstalling libpng via macports resolved the issue and allowed gcc finish building.
sudo port clean libpng sudo port install libpng sudo port install gcc45

Afterwards, rename /opt/local-temp to /opt-local.

If you type gcc –version at the command line the version install with XCode will probably run. This is because the Macports version is named gcc-mp-45. Using Macports install gcc_select.

sudo port install gcc_select

gcc_select –l will list the available versions of gcc, and gcc_select mp-gcc45 will make version 4.5 the default. This changes the symbolic link for /opt/local/bin/gcc. I also had to add the new symbolic link to /usr/local/bin/gcc (make a copy of the original) in order to get everything to work correctly.

WGS84 Ellipsoid Calculations

Paul — Wed, 14 Jul 2010 10:05:44 +0000

(source code links below)
12/7/2010, added support for building as a DLL and using within Microsoft Excel VBA.

In late 2008, I was in negotiations with an aviation company to write some navigation design software. I use to work for the company and was already familiar with their software stacks and engineering processes. Quite a few of the applications the company uses, I had written or helped implement. The chances of actually getting the contract were slim though. Internal growth of the company was fast, and different departments were motivated to go a different direction than the department I was in talks with.

Even though the chances of getting the contract were slim, I wanted to get a jump on some crucial code that would be required from the onset. So I set out on October 15, 2008, to write all the formulas described in FAA Order 8260.54A, Appendix 2, and a test harness for the data published in attachment C of the same document.

Initially I figured it would take 2 to 4 weeks to write the library and test harness based on the completeness of 8260.54A. Almost immediately, I discovered the document to have many errors and omissions, which caused days long investigations into why the formulas didn’t produce the expected test results (the projects code, comments and file Application test Results.txt document some of the problems and how they are resolved).

On December 18, 2008, I finished the work, had no contract, but was proud that I’d resolved each and every formula in Appendix 2 and they produced the expected test results. Now, a year and a half later, I’m releasing the code for the formulas and test harness.

I wrote a standalone WGS84 Geodesic Calculator (beta) for Windows based on the formulas, and some people from the GeoCache community have used it to create and solve complicated puzzles.

The hardest part about releasing the code was which license to choose. Ultimately I decided for the liberal Apache License, Version 2.0, and it’s my contribution to the open source community.

WGS84 Ellipsoid Calculation Types

Arc Intercept	Geodesic Locus Intersect	Point on LocusP
Course Intersect	Geometric Mean Meridional	Point to Arc Tangents
Direct Arc Length	Locus Arc Intersect	Pt is on Arc
Discretized Arc Length	Locus Course at Point	Pt is on Geodesic
Distance Intersection	Locus Intersect	Pt is on Locus
Distance to LocusP	Locus Perpendicular Intercept	Tangent Fixed Radius Arc
Distance to LocusD	Locus Tangent Fixed Radius Arc	Vincenty Direct
ECEF	Perpendicular Intercept	Vincenty Inverse
Geodesic Arc Intercept	Perpendicular Tangent Points

There are a few other implemented formulas which are support to the ones listed above. Also, the TerpsTest code for validating the formulas is a good source to see how to use the formulas in your own code.

Available Source Code

The GeoFormulas and TerpsTest (test harness) code is hosted on GitHub, and released under the Apache License, Version 2.0. Note: TerpsTest requires Boost::RegEx. Outside of STL, GeoFormulas is not dependent on external libraries.

The source code for the standalone Windows WGS84 Geodesic Calculator is not available at this time.

N-dimension array initialization

Paul — Tue, 13 Jul 2010 01:07:41 +0000

In the previous article Container assignment list I show how to assign items to STL containers using a list of items separated by a comma.

This example will show how to do the same with a N-dimensional array, with debug build bounds checking. First an example which shows how to declare and initialize a N-dimensional array of type int or type double with a comma separated list of items.

// define a 3 dimensional array of int's
// and initialize.
MyArray<int, 3> intArray3D;
intArray3D = 1, 2, 3;
 
// define a 2 diemsional array of double's
// and initialize.
MyArray<double, 2> doubleArray2D;
doubleArray2D = 10.0, 20.0;
 
// define a 3 x 3 matrix of double and initialize
MyArray<double, 9> doubleMatrix3x3;
doubleMatrix3x3 = 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0;

The N-Dimensional array class implementation

The array class code below only shows enough code to get the assignment and comma operator overloaded. Other useful code and overloads that this class would have is not shown, in order to keep the discussion simple and on topic.

MyArray Class

template<class T, int ArraySize>
class MyArray
{
public:
    MyArray()
    {
        assert(ArraySize != 0);
        // Set items in array to 0
        for(size_t i = 0; i < ArraySize; ++i)
            m_array[i] = 0;
    }
 
    Initializer<T, ArraySize> operator=(T val)
    {
        // store RHS of = to first array item location
        m_array[0] = val;
 
        // Call Initializer construct with address of m_array[1],
        // return Initializer object.
        // Allows the overloaded comma operator for Initializer
        // to be called repeatedly.
        return Initializer<T, ArraySize>(&m_array[1]);
    }
private:
    T m_array[ArraySize];
};

MyArray is a template class that needs 2 template parameters, the first is the type of array to create, and the second is the number of elements the array can store.

The default constructor assigns 0 to each element in the array, if this does not make sense for the type object being stored in the array then modify as needed.

The overloaded assignment operator takes the first item in the list, right of the = sign (RHS), and assigns it to first position in the array. It then calls Initializer’s constructor with the address of the second element in the array, and returns the Initializer object.

This sets up Initializer, which overloads the comma operator, to handle the rest of the assignment list. Overloading the assignment and comma operators is discussed in the article Container assignment list.

The Initializer class is simple and documented below.

Initializer Class for MyArray

// Initializer class. Helper class for MyArray,
// keeping track of the current element being
// assigned, with the overloaded comma operator,
template<class T, int ArraySize>
class Initializer
{
public:
    Initializer() : m_ptr(0)
    {
        #ifndef NDEBUG
            m_nCount = 0;
        #endif
    }
 
    // Constructor called by MyArray operator=
    // ptr will equal MyArray::m_array[1]. Since
    // For debug builds set m_nCount to 1 since
    // MyArray already assigned element [0].
    Initializer(T * ptr) : m_ptr(ptr)
    {
        #ifndef NDEBUG
            m_nCount = 1;
        #endif
    }
 
    // Overloaded comma operator
    Initializer & operator,(T val)
    {
        #ifndef NDEBUG
            // Debug assert for array overrun
            assert(m_nCount < ArraySize);
            ++m_nCount;
        #endif
 
        // store value in pointer to array, then
        // increment pointer to array to next location
        *m_ptr++ = val;
        return *this;
    }
private:
    // Pointer to array location
    T * m_ptr;
    #ifndef NDEBUG
        int m_nCount;
    #endif
};

Container assignment lists

Paul — Fri, 09 Jul 2010 01:57:49 +0000

A few weeks ago while reading the Blitz++ Documentation I noticed Blitz++ was initializing Matrices and other containers using commas.

Container<int> bucket;
bucket = 1, 2, 3, 4, 5;

Finding this both useful and cool, had to figure out how it was done.

But first…

If the container has a std::vector member then a constructor taking both the start and end of the array can be used to initialize vector. First an array is initialized, and the beginning and end of the array is passed to the container’s constructor.

const int elements = 5;
int a[elements] = {1, 2, 3, 4, 5, };
Container<int> vec(a, &a[elements]);

Although this is doable it isn’t flexible and you might be incline to code a bunch of push_back calls

Container<int> vec;
vec.push_back(1);
vec.push_back(2);
vec.push_back(3);
vec.push_back(4);
vec.push_back(5);

If we have to go that route it would be much nicer to write code as shown at the beginning of the article.

Overloading a couple operators

The goal again, is to be able to write code such as

Container<int> bucket;
bucket = 1, 2, 3, 4, 5;

which assigns values to a container using a list.

Below is code for a template container class that has std::vector as a member. Only the two operators to be overloaded are shown in the example.

Container class

template<class T>
class Container
{
public:
 std::vector<T> & operator=(const T & nVal) {
 m_vector.clear();
 m_vector.push_back(nVal);
 return m_vector;
 }
 friend std::vector<T> & operator,(std::vector<T> & lst, T val)
 {
 lst.push_back(val);
 return lst;
 }
 std::vector<T> m_vector;
};

Assignment operator

The assignment operator is overloaded to take a const reference T as the first parameter and returns a reference to m_vector. In the previous examples T is an int. When the compiler sees

bucket = 1

it grabs the value to the right of = and if the correct type, produces code for the assignment operator. The overloaded operator= first clears the contents of m_vector, then pushes the value onto m_vector.

The assignment operator returns a reference of m_vector which allows the overloaded comma operator to be called from the assignment list.

Comma operator

The second operator overloaded for the container class is the comma operator, which evaluates the object type to the left, evaluates the object type to the right and operates on it.

For the purposes of the example, the assignment operator returned a reference to std::vector (m_vector) from the first item in the list.

bucket = 1, 2, 3, 4, 5;

The compiler uses the returned type on the first seen comma (LHS), looks to the right of the comma and sees it is an int type (RHS). This matches the overloaded comma operator’s definition of

friend std::vector<int> & operator,(std::vector<int> & lst, int val)

Since the comma operator is a binary operator, it needs have global scope and declaring the function as a friend provides that.

For the container class the overloaded comma operator simply pushes the RHS hand value onto the LHS object, and returns a reference to the std::vector (m_vector), and repeats until no items in the list are left.

Conclusion

This type of operator overloading can eliminate ugly lists of repeated push_back calls and can easily be used with the other STL containers.

It is important that your container class has a member of the STL container you want to use. Do not inherit from one of the STL containers. They do not have a virtual destructor, which is needed for a derived class.