This file is indexed.

/usr/include/claw/pixel.hpp is in libclaw-graphic-dev 1.7.3-1+b2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
/*
  CLAW - a C++ Library Absolutely Wonderful

  CLAW is a free library without any particular aim but being useful to 
  anyone.

  Copyright (C) 2005-2011 Julien Jorge

  This library 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 2.1 of the License, or (at your option) any later version.

  This library 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 library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

  contact: julien.jorge@gamned.org
*/
/**
 * \file pixel.hpp
 * \brief Representation of a pixel in image processing.
 * \author Julien Jorge
 */
#ifndef __CLAW_PIXEL_HPP_
#define __CLAW_PIXEL_HPP_

#include <string>

namespace claw
{
  namespace graphic
  {
    struct rgba_pixel;

    /**
     * \brief RGB pixel.
     */
    struct rgb_pixel
    {
      /** \brief The type of the components of the color. */
      typedef unsigned char component_type;

      /** \brief Component by component representation. */
      struct
      {
        /** \brief Red component. */
        component_type red;

        /** \brief Green component. */
        component_type green;

        /** \brief Blue component. */
        component_type blue;

      } components; 

    public:
      rgb_pixel();
      rgb_pixel( component_type r, component_type g, component_type b );
      rgb_pixel( const rgba_pixel& p );
      explicit rgb_pixel( const std::string& c );

      bool operator==(const rgb_pixel& that) const;
      bool operator==(const rgba_pixel& that) const;
      bool operator!=(const rgb_pixel& that) const;
      bool operator!=(const rgba_pixel& that) const;

    }; // struct rgb_pixel

    /**
     * \brief RGBA pixel.
     */
    struct rgba_pixel
    {
      /** \brief The type of the components of the color. */
      typedef unsigned char component_type;

      union
      {
	/** \brief Compressed representation. */
	unsigned int pixel;

	/** \brief Component by component representation. */
	struct
	{
	  /** \brief Red component. */
	  component_type red;

	  /** \brief Green component. */
	  component_type green;

	  /** \brief Blue component. */
	  component_type blue;

	  /** \brief Translucy. */
	  component_type alpha;

	} components;
      };

    public:
      rgba_pixel();
      rgba_pixel( const rgb_pixel& that );
      rgba_pixel( component_type r, component_type g, component_type b,
                  component_type a );
      explicit rgba_pixel( const std::string& c );

      rgba_pixel& operator=( const rgb_pixel& that );
      bool operator==( const rgba_pixel& that ) const;
      bool operator!=( const rgba_pixel& that ) const;

      component_type luminosity() const;

    }; // struct rgba_pixel

    /** \brief A color with 8 bits per component. */
    typedef rgb_pixel rgb_pixel_8;

    /** \brief A color with 8 bits per component and an alpha channel. */
    typedef rgba_pixel rgba_pixel_8;

    /** \defgroup Colors Colors.
     * \{
     */

    /** \brief A transparent color. */
    extern rgba_pixel transparent_pixel;

    /** \brief The black color. */
    extern rgba_pixel black_pixel;

    /** \brief The white color. */
    extern rgba_pixel white_pixel;

    /** \brief The blue color. */
    extern rgba_pixel blue_pixel;

    /** \brief The green color. */
    extern rgba_pixel green_pixel;

    /** \brief The red color. */
    extern rgba_pixel red_pixel;

    /** \brief The yellow color. */
    extern rgba_pixel yellow_pixel;

    /** \brief The magenta color. */
    extern rgba_pixel magenta_pixel;

    /** \brief The cyan color. */
    extern rgba_pixel cyan_pixel;

    /** \} */

  } // namespace graphic
} // namespace claw

#endif // __CLAW_PIXEL_HPP__