Skip to content

GitLab

"git@developer.sourcefind.cn:OpenDAS/megatron-lm.git" did not exist on "35cb3cc146e9e28ae16ac91e3e9bfdcf0ccb35e3"
Commit 44d22340 authored by Davis King's avatar Davis King
Browse files

Removed the pixel.cpp file and moved the few things that were 

in it into pixel.h.  I did this to make sure that all the things
that #include pixel.h are always "header-only" since most of
dlib is header-only already.

--HG--
extra : convert_revision : svn%3Afdd8eb12-d10e-0410-9acb-85c331704f74/trunk%402934
parent 937f61b8
Hide whitespace changes
Inline Side-by-side
Showing with 198 additions and 240 deletions
dlib/all/source.cpp
View file @ 44d22340
......@@ -13,7 +13,6 @@
#include "../entropy_encoder/entropy_encoder_kernel_1.cpp"
#include "../entropy_encoder/entropy_encoder_kernel_2.cpp"
#include "../md5/md5_kernel_1.cpp"
#include "../pixel.cpp"
#include "../tokenizer/tokenizer_kernel_1.cpp"
#include "../unicode/unicode.cpp"
......
dlib/pixel.cpp deleted 100644 → 0
View file @ 937f61b8
// Copyright (C) 2006 Davis E. King (davisking@users.sourceforge.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_PIXEL_CPp_
#define DLIB_PIXEL_CPp_
#include "pixel.h"
namespace dlib
{
// ----------------------------------------------------------------------------------------
void serialize (
const rgb_alpha_pixel& item,
std::ostream& out
)
{
try
{
serialize(item.red,out);
serialize(item.green,out);
serialize(item.blue,out);
serialize(item.alpha,out);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing object of type rgb_alpha_pixel");
}
}
// ----------------------------------------------------------------------------------------
void deserialize (
rgb_alpha_pixel& item,
std::istream& in
)
{
try
{
deserialize(item.red,in);
deserialize(item.green,in);
deserialize(item.blue,in);
deserialize(item.alpha,in);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while deserializing object of type rgb_alpha_pixel");
}
}
// ----------------------------------------------------------------------------------------
void serialize (
const rgb_pixel& item,
std::ostream& out
)
{
try
{
serialize(item.red,out);
serialize(item.green,out);
serialize(item.blue,out);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing object of type rgb_pixel");
}
}
// ----------------------------------------------------------------------------------------
void deserialize (
rgb_pixel& item,
std::istream& in
)
{
try
{
deserialize(item.red,in);
deserialize(item.green,in);
deserialize(item.blue,in);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while deserializing object of type rgb_pixel");
}
}
// ----------------------------------------------------------------------------------------
void serialize (
const hsi_pixel& item,
std::ostream& out
)
{
try
{
serialize(item.h,out);
serialize(item.s,out);
serialize(item.i,out);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing object of type hsi_pixel");
}
}
// ----------------------------------------------------------------------------------------
void deserialize (
hsi_pixel& item,
std::istream& in
)
{
try
{
deserialize(item.h,in);
deserialize(item.s,in);
deserialize(item.i,in);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while deserializing object of type hsi_pixel");
}
}
// ----------------------------------------------------------------------------------------
namespace assign_pixel_helpers
{
/*
I found this excellent bit of code at
http://local.wasp.uwa.edu.au/~pbourke/colour/hsl/
*/
/*
Calculate HSL from RGB
Hue is in degrees
Lightness is between 0 and 1
Saturation is between 0 and 1
*/
HSL RGB2HSL(COLOUR c1)
{
double themin,themax,delta;
HSL c2;
using namespace std;
themin = min(c1.r,min(c1.g,c1.b));
themax = max(c1.r,max(c1.g,c1.b));
delta = themax - themin;
c2.l = (themin + themax) / 2;
c2.s = 0;
if (c2.l > 0 && c2.l < 1)
c2.s = delta / (c2.l < 0.5 ? (2*c2.l) : (2-2*c2.l));
c2.h = 0;
if (delta > 0) {
if (themax == c1.r && themax != c1.g)
c2.h += (c1.g - c1.b) / delta;
if (themax == c1.g && themax != c1.b)
c2.h += (2 + (c1.b - c1.r) / delta);
if (themax == c1.b && themax != c1.r)
c2.h += (4 + (c1.r - c1.g) / delta);
c2.h *= 60;
}
return(c2);
}
/*
Calculate RGB from HSL, reverse of RGB2HSL()
Hue is in degrees
Lightness is between 0 and 1
Saturation is between 0 and 1
*/
COLOUR HSL2RGB(HSL c1)
{
COLOUR c2,sat,ctmp;
using namespace std;
if (c1.h < 120) {
sat.r = (120 - c1.h) / 60.0;
sat.g = c1.h / 60.0;
sat.b = 0;
} else if (c1.h < 240) {
sat.r = 0;
sat.g = (240 - c1.h) / 60.0;
sat.b = (c1.h - 120) / 60.0;
} else {
sat.r = (c1.h - 240) / 60.0;
sat.g = 0;
sat.b = (360 - c1.h) / 60.0;
}
sat.r = min(sat.r,1.0);
sat.g = min(sat.g,1.0);
sat.b = min(sat.b,1.0);
ctmp.r = 2 * c1.s * sat.r + (1 - c1.s);
ctmp.g = 2 * c1.s * sat.g + (1 - c1.s);
ctmp.b = 2 * c1.s * sat.b + (1 - c1.s);
if (c1.l < 0.5) {
c2.r = c1.l * ctmp.r;
c2.g = c1.l * ctmp.g;
c2.b = c1.l * ctmp.b;
} else {
c2.r = (1 - c1.l) * ctmp.r + 2 * c1.l - 1;
c2.g = (1 - c1.l) * ctmp.g + 2 * c1.l - 1;
c2.b = (1 - c1.l) * ctmp.b + 2 * c1.l - 1;
}
return(c2);
}
}
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_PIXEL_CPp_
dlib/pixel.h
View file @ 44d22340
......@@ -246,7 +246,7 @@ namespace dlib
// ----------------------------------------------------------------------------------------
void serialize (
inline void serialize (
const rgb_pixel& item,
std::ostream& out
);
......@@ -256,7 +256,7 @@ namespace dlib
// ----------------------------------------------------------------------------------------
void deserialize (
inline void deserialize (
rgb_pixel& item,
std::istream& in
);
......@@ -266,7 +266,7 @@ namespace dlib
// ----------------------------------------------------------------------------------------
void serialize (
inline void serialize (
const rgb_alpha_pixel& item,
std::ostream& out
);
......@@ -276,7 +276,7 @@ namespace dlib
// ----------------------------------------------------------------------------------------
void deserialize (
inline void deserialize (
rgb_alpha_pixel& item,
std::istream& in
);
......@@ -286,7 +286,7 @@ namespace dlib
// ----------------------------------------------------------------------------------------
void serialize (
inline void serialize (
const hsi_pixel& item,
std::ostream& out
);
......@@ -296,7 +296,7 @@ namespace dlib
// ----------------------------------------------------------------------------------------
void deserialize (
inline void deserialize (
hsi_pixel& item,
std::istream& in
);
......@@ -531,20 +531,85 @@ namespace dlib
};
/*
Calculate HSL from RGB
Hue is in degrees
Lightness is between 0 and 1
Saturation is between 0 and 1
I found this excellent bit of code for dealing with HSL spaces at
http://local.wasp.uwa.edu.au/~pbourke/colour/hsl/
*/
HSL RGB2HSL(COLOUR c1);
/*
Calculate HSL from RGB
Hue is in degrees
Lightness is between 0 and 1
Saturation is between 0 and 1
*/
inline HSL RGB2HSL(COLOUR c1)
{
double themin,themax,delta;
HSL c2;
using namespace std;
themin = min(c1.r,min(c1.g,c1.b));
themax = max(c1.r,max(c1.g,c1.b));
delta = themax - themin;
c2.l = (themin + themax) / 2;
c2.s = 0;
if (c2.l > 0 && c2.l < 1)
c2.s = delta / (c2.l < 0.5 ? (2*c2.l) : (2-2*c2.l));
c2.h = 0;
if (delta > 0) {
if (themax == c1.r && themax != c1.g)
c2.h += (c1.g - c1.b) / delta;
if (themax == c1.g && themax != c1.b)
c2.h += (2 + (c1.b - c1.r) / delta);
if (themax == c1.b && themax != c1.r)
c2.h += (4 + (c1.r - c1.g) / delta);
c2.h *= 60;
}
return(c2);
}
/*
Calculate RGB from HSL, reverse of RGB2HSL()
Hue is in degrees
Lightness is between 0 and 1
Saturation is between 0 and 1
Calculate RGB from HSL, reverse of RGB2HSL()
Hue is in degrees
Lightness is between 0 and 1
Saturation is between 0 and 1
*/
COLOUR HSL2RGB(HSL c1);
inline COLOUR HSL2RGB(HSL c1)
{
COLOUR c2,sat,ctmp;
using namespace std;
if (c1.h < 120) {
sat.r = (120 - c1.h) / 60.0;
sat.g = c1.h / 60.0;
sat.b = 0;
} else if (c1.h < 240) {
sat.r = 0;
sat.g = (240 - c1.h) / 60.0;
sat.b = (c1.h - 120) / 60.0;
} else {
sat.r = (c1.h - 240) / 60.0;
sat.g = 0;
sat.b = (360 - c1.h) / 60.0;
}
sat.r = min(sat.r,1.0);
sat.g = min(sat.g,1.0);
sat.b = min(sat.b,1.0);
ctmp.r = 2 * c1.s * sat.r + (1 - c1.s);
ctmp.g = 2 * c1.s * sat.g + (1 - c1.s);
ctmp.b = 2 * c1.s * sat.b + (1 - c1.s);
if (c1.l < 0.5) {
c2.r = c1.l * ctmp.r;
c2.g = c1.l * ctmp.g;
c2.b = c1.l * ctmp.b;
} else {
c2.r = (1 - c1.l) * ctmp.r + 2 * c1.l - 1;
c2.g = (1 - c1.l) * ctmp.g + 2 * c1.l - 1;
c2.b = (1 - c1.l) * ctmp.b + 2 * c1.l - 1;
}
return(c2);
}
// -----------------------------
......@@ -916,14 +981,127 @@ namespace dlib
return get_pixel_intensity_helper(src);
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
}
inline void serialize (
const rgb_alpha_pixel& item,
std::ostream& out
)
{
try
{
serialize(item.red,out);
serialize(item.green,out);
serialize(item.blue,out);
serialize(item.alpha,out);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing object of type rgb_alpha_pixel");
}
}
// ----------------------------------------------------------------------------------------
inline void deserialize (
rgb_alpha_pixel& item,
std::istream& in
)
{
try
{
deserialize(item.red,in);
deserialize(item.green,in);
deserialize(item.blue,in);
deserialize(item.alpha,in);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while deserializing object of type rgb_alpha_pixel");
}
}
// ----------------------------------------------------------------------------------------
inline void serialize (
const rgb_pixel& item,
std::ostream& out
)
{
try
{
serialize(item.red,out);
serialize(item.green,out);
serialize(item.blue,out);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing object of type rgb_pixel");
}
}
// ----------------------------------------------------------------------------------------
inline void deserialize (
rgb_pixel& item,
std::istream& in
)
{
try
{
deserialize(item.red,in);
deserialize(item.green,in);
deserialize(item.blue,in);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while deserializing object of type rgb_pixel");
}
}
// ----------------------------------------------------------------------------------------
inline void serialize (
const hsi_pixel& item,
std::ostream& out
)
{
try
{
serialize(item.h,out);
serialize(item.s,out);
serialize(item.i,out);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing object of type hsi_pixel");
}
}
// ----------------------------------------------------------------------------------------
inline void deserialize (
hsi_pixel& item,
std::istream& in
)
{
try
{
deserialize(item.h,in);
deserialize(item.s,in);
deserialize(item.i,in);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while deserializing object of type hsi_pixel");
}
}
#ifdef NO_MAKEFILE
#include "pixel.cpp"
#endif
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_PIXEl_
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment