What Do I Pass for inputGeometryTransform Parameter of ID2D1Geometry::CompareWithGeometry?

As said in the comment, the inputGeometryTransform Parameter is used to scale, rotate or translate the target geometry before it is compared with the host geometry. Without that translation, geometries will be processed relative to where their figure began in their associated Geometry Sinks; unfortunately, only being able to scale the target geometry was a bit awkward for me so I found an interesting function called CreateTransformedGeometry. Using a few MSDN examples, I was able to create this function that was useful to me:

// This is Shawn Eary's code and it is licenced under the
// Microsoft Public License (Ms-PL) which is compatible with the 
// Open Source Initiative
//
// Shawn Eary is not affiliated with Microsoft.  
// He just likes the Ms-PL
// 
// References and Influences Used: 
// http://msdn.microsoft.com/en-us/library/windows/desktop/dd742769(v=vs.85).aspx
// http://msdn.microsoft.com/en-us/library/windows/desktop/dd742730(v=vs.85).aspx
HRESULT TransformGeometry(
    ID2D1Geometry *ipGeometryToTransform,
    ID2D1Geometry **oppTranformedGeometry, 
    D2D1_MATRIX_3X2_F const & transform
    )
{
    HRESULT hr;
    ID2D1Factory *pFactory = NULL;
    ipGeometryToTransform->GetFactory(&pFactory);

    ID2D1TransformedGeometry *pTransformedGeometry = NULL;
    hr = pFactory->CreateTransformedGeometry(
        ipGeometryToTransform,
        transform,
        &pTransformedGeometry
     );

    *oppTranformedGeometry = pTransformedGeometry;
    (*oppTranformedGeometry)->AddRef();
    pTransformedGeometry->Release();

    return hr;
}

Then, using the new TransformGeometry function, my UpdateDynamics code could then could be rewritten for hit-testing like this:

// This is Shawn Eary's code and it is licenced under the
// Microsoft Public License (Ms-PL) which is compatible with the 
// Open Source Initiative
//
// Shawn Eary is not affiliated with Microsoft.  
// He just likes the Ms-PL
void SpaceObject::updateDynamics(
    Microsoft::WRL::ComPtr<ID2D1DeviceContext> const i_d2dContext)
{
    D2D1_SIZE_F renderTargetSize = i_d2dContext->GetSize();
    float const worldWidth = renderTargetSize.width / 2.0f; 
    float const halfWorldWidth = worldWidth / 2.0f; 
    float const worldHeight = renderTargetSize.height / 2.0f; 
    float const halfWorldHieght = worldHeight / 2.0f; 

    // Update the position in ideal coordinates
    double idealX = m_p.x + m_v.x;
    double idealY = m_p.y + m_v.y; 

    // Account for wrap around  
    m_p.x = getWrappedResult(idealX, worldWidth); 
    m_p.y = getWrappedResult(idealY, worldHeight); 
    m_p.theta += m_v.theta; 

    m_v.x += m_a.x;
    m_v.y += m_a.y; 
    m_v.theta += m_a.theta; 

    // Compute results of elastic collisions
    for (list<SpaceObject *>::iterator it = m_myObjectWorldP->begin(); it != m_myObjectWorldP->end(); it++) {
        SpaceObject * const SOP = (*it);

        // This eventually needs to be fixed, but for now assume all 
        // spaceObjects are GeometrySpaceObjects 
        GeometrySpaceObject * thisGSOP = dynamic_cast<GeometrySpaceObject*>(this); 
        GeometrySpaceObject * currentGSOP = dynamic_cast<GeometrySpaceObject*>(SOP); 

        // Don't compare this SpaceObject with itself
        if (thisGSOP != currentGSOP) {
            D2D1_MATRIX_3X2_F thisTransform = thisGSOP->gTransformation();
            D2D1_MATRIX_3X2_F currentTransform = currentGSOP->gTransformation();
            ID2D1PathGeometry * const thisGP = thisGSOP->gGeoP(); 
            ID2D1PathGeometry * const curGP = currentGSOP->gGeoP();

            D2D1_GEOMETRY_RELATION theRelation; 
            ID2D1Geometry * thisTGP; 
            TransformGeometry(thisGP, &thisTGP, thisTransform); 
            ID2D1Geometry * currentTGP; 
            TransformGeometry(curGP, &currentTGP, currentTransform); 
            thisTGP->CompareWithGeometry(
                (ID2D1Geometry *)currentTGP, 
                NULL, 
                &theRelation
            );          
            thisTGP->Release(); 
            currentTGP->Release(); 
            if (theRelation != D2D1_GEOMETRY_RELATION_DISJOINT) {

                // A Collision has occured.
                // 
                // Use conservation of momentum to update 
                // velocities after collission here
                int placeHolder = 0; 
            }           
        }
    }   

    this->updateAcceleration();     
}