CoordinateConverter.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2011, SRI International (R)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef __OpenKarto_CoordinateConverter_h__
#define __OpenKarto_CoordinateConverter_h__

#include <OpenKarto/Geometry.h>

namespace karto
{




  class CoordinateConverter
  {
  public:
    CoordinateConverter()
      : m_Scale(20.0)
    {
    }

  public:
    KARTO_DEPRECATED inline kt_double Transform(kt_double value)
    {
      return value * m_Scale;
    }

    inline Vector2i WorldToGrid(const Vector2d& rWorld, kt_bool flipY = false) const
    {
      kt_double gridX = (rWorld.GetX() - m_Offset.GetX()) * m_Scale;
      kt_double gridY = 0.0;

      if (flipY == false)
      {
        gridY = (rWorld.GetY() - m_Offset.GetY()) * m_Scale;
      }
      else
      {
        gridY = (m_Size.GetHeight() / m_Scale - rWorld.GetY() + m_Offset.GetY()) * m_Scale;
      }

      return Vector2i(static_cast<kt_int32s>(math::Round(gridX)), static_cast<kt_int32s>(math::Round(gridY)));
    }

    inline Vector2d GridToWorld(const Vector2i& rGrid, kt_bool flipY = false) const
    {
      kt_double worldX = m_Offset.GetX() + rGrid.GetX() / m_Scale;
      kt_double worldY = 0.0;
      
      if (flipY == false)
      {
        worldY = m_Offset.GetY() + rGrid.GetY() / m_Scale;
      }
      else
      {
        worldY = m_Offset.GetY() + (m_Size.GetHeight() - rGrid.GetY()) / m_Scale;
      }

      return Vector2d(worldX, worldY);
    }

    inline kt_double GetScale() const
    {
      return m_Scale;
    }
    
    inline void SetScale(kt_double scale)
    {
      m_Scale = scale;
    }

    inline const Vector2d& GetOffset() const
    {
      return m_Offset;
    }

    inline void SetOffset(const Vector2d& rOffset)
    {
      m_Offset = rOffset;
    }
    
    inline void SetSize(const Size2<kt_int32s>& rSize)
    {
      m_Size = rSize;
    }

    inline const Size2<kt_int32s>& GetSize() const
    {
      return m_Size;
    }

    inline kt_double GetResolution() const
    {
      return 1.0 / m_Scale;
    }

    inline void SetResolution(kt_double resolution)
    {
      m_Scale = 1.0 / resolution;
    }
    
    inline BoundingBox2 GetBoundingBox() const
    {
      BoundingBox2 box;
      
      kt_double minX = GetOffset().GetX();
      kt_double minY = GetOffset().GetY();
      kt_double maxX = minX + GetSize().GetWidth() * GetResolution();
      kt_double maxY = minY + GetSize().GetHeight() * GetResolution();
      
      box.SetMinimum(GetOffset());
      box.SetMaximum(Vector2d(maxX, maxY));
      return box;
    }
    
  private:
    Size2<kt_int32s> m_Size;
    kt_double m_Scale;

    Vector2d m_Offset;
  }; // CoordinateConverter


}

#endif // __OpenKarto_CoordinateConverter_h__