plotcover.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file plotcover.h
///
/// Plotting a cover in a bitmap image file.
/// This file contains the definition of a function that plots a cover
/// in a bitmap image file.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 1997-2010 by Pawel Pilarczyk.
//
// This file is part of my research software package.  This is free software;
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation;
// either version 2 of the License, or (at your option) any later version.
//
// This software 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this software; see the file "license.txt".  If not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started on March 14, 2009. Last revision: March 19, 2009.


#ifndef _FINRESDYN_PLOTCOVER_H_
#define _FINRESDYN_PLOTCOVER_H_


// include selected header files from the CHomP library
#include "chomp/system/textfile.h"
#include "chomp/bitmaps/bitmaps.h"

// include local header files
#include "streams.h"


// --------------------------------------------------
// ------------------ plot a cover ------------------
// --------------------------------------------------

template <class CoverType>
inline void plotCover (const CoverType &cover, const char *filename,
        int width)
{
        using namespace chomp::homology;

        // make sure that the dimension of the phase space is two
        if (cover. dim () != 2)
                throw "Trying to plot a cover of dimension other than 2.";

        // retrieve the type of numbers used in the cover
        typedef typename CoverType::NumberType NumType;

        // retrieve the left corner of the covered rectangle
        NumType leftCorner [2];
        cover. getLeftCorner (leftCorner);

        // retrieve the widths of the covered box in each direction
        NumType boxWidths [2];
        cover. getBoxWidths (boxWidths);

        // make sure that the requested width of the bitmap file is correct
        if (width < 1)
                width = 1;

        // determine the height of the bitmap file
        int height = static_cast <int> (boxWidths [1] / boxWidths [0] *
                width + 1);
        if (height < 1)
                height = 1;

        // create an empty bitmap file
        bmpfile bmp (height);
        bmp. invertedpicture ();
        const int pallength = 3;
        int32 palette [pallength] = {0x000000, 0x7F7F7F, 0xFFFFFF};
        bmp. create (filename, width, height, 4, pallength, palette);

        // plot the elements of the cover
        NumType leftBounds [2];
        NumType rightBounds [2];
        int left [2];
        int right [2];
        int bmpSize [2];
        bmpSize [0] = width;
        bmpSize [1] = height;
        for (int n = 0; n < cover. size (); ++ n)
        {
                cover. get (n, leftBounds, rightBounds);
                for (int i = 0; i < 2; ++ i)
                {
                        left [i] = static_cast<int> ((leftBounds [i] -
                                leftCorner [i]) / boxWidths [i] *
                                bmpSize [i]);
                        if (left [i] >= bmpSize [i])
                                left [i] = bmpSize [i] - 1;
                        right [i] = static_cast<int> ((rightBounds [i] -
                                leftCorner [i]) / boxWidths [i] *
                                bmpSize [i]) + 1;
                        if (right [i] > bmpSize [i])
                                right [i] = bmpSize [i] - 1;
                        if (right [i] <= left [i])
                                right [i] = left [i] + 1;
                }

                for (int x = left [0]; x < right [0]; ++ x)
                {
                        for (int y = left [1]; y < right [1]; ++ y)
                        {
                                int color = 1;
                                if ((x == left [0]) ||
                                        (x == right [0] - 1) ||
                                        (y == left [1]) ||
                                        (y == right [1] - 1))
                                {
                                        color = 0;
                                }
                                bmp. putpixel (x, y, color, true);
                        }
                }
        }

        return;
} /* plotCover */

#endif // _FINRESDYN_PLOTCOVER_H_