VCG Library
Loading...
Searching...
No Matches
color.h
1/****************************************************************************
2* VCGLib o o *
3* Visual and Computer Graphics Library o o *
4* _ O _ *
5* Copyright(C) 2004-2016 \/)\/ *
6* Visual Computing Lab /\/| *
7* ISTI - Italian National Research Council | *
8* \ *
9* All rights reserved. *
10* *
11* This program is free software; you can redistribute it and/or modify *
12* it under the terms of the GNU General Public License as published by *
13* the Free Software Foundation; either version 2 of the License, or *
14* (at your option) any later version. *
15* *
16* This program is distributed in the hope that it will be useful, *
17* but WITHOUT ANY WARRANTY; without even the implied warranty of *
18* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
20* for more details. *
21* *
22****************************************************************************/
23
24#ifndef __VCG_TRI_UPDATE_COLOR
25#define __VCG_TRI_UPDATE_COLOR
26
27#include <math.h>
28#include <time.h>
29#include <vcg/space/color4.h>
30#include <vcg/space/colormap.h>
31#include <vcg/math/histogram.h>
32#include <vcg/math/perlin_noise.h>
33#include <vcg/math/random_generator.h>
34#include <vcg/complex/algorithms/clean.h>
35#include <vcg/complex/algorithms/stat.h>
36
37namespace vcg {
38namespace tri {
39
52template <class MeshType>
53class UpdateColor
54{
55public:
56 typedef typename MeshType::VertexType VertexType;
57 typedef typename MeshType::VertexPointer VertexPointer;
58 typedef typename MeshType::VertexIterator VertexIterator;
59 typedef typename MeshType::FaceType FaceType;
60 typedef typename MeshType::FacePointer FacePointer;
61 typedef typename MeshType::FaceIterator FaceIterator;
62 typedef typename MeshType::EdgeIterator EdgeIterator;
63 typedef typename MeshType::TetraType TetraType;
64 typedef typename MeshType::TetraPointer TetraPointer;
65 typedef typename MeshType::TetraIterator TetraIterator;
66
67
68 typedef typename MeshType::ScalarType ScalarType;
69 typedef typename MeshType::CoordType CoordType;
70
71 class ColorAvgInfo
72 {
73 public:
74 unsigned int r = 0;
75 unsigned int g = 0;
76 unsigned int b = 0;
77 unsigned int a = 0;
78 int cnt = 0;
79 };
80
83 static int PerVertexConstant(MeshType &m, Color4b vs=Color4b::White,bool selected=false)
84 {
85 RequirePerVertexColor(m);
86
87 int cnt=0;
88 for(VertexIterator vi=m.vert.begin();vi!=m.vert.end();++vi)
89 if(!(*vi).IsD()){
90 if(!selected || (*vi).IsS())
91 {
92 (*vi).C() = vs;
93 ++cnt;
94 }
95 }
96 return cnt;
97 }
98
101 static int PerFaceConstant(MeshType &m, Color4b vs=Color4b::White,bool selected=false)
102 {
103 RequirePerFaceColor(m);
104 int cnt=0;
105 for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi)
106 if(!(*fi).IsD()){
107 if(!selected || (*fi).IsS())
108 {
109 (*fi).C() = vs;
110 ++cnt;
111 }
112 }
113 return cnt;
114 }
115
118 static int PerTetraConstant(MeshType & m, Color4b vs = Color4b::White, bool selected = false)
119 {
120 RequirePerTetraColor(m);
121 int cnt = 0;
122 ForEachTetra(m, [&] (TetraType & t) {
123 if (!selected || t.IsS())
124 {
125 t.C() = vs;
126 ++cnt;
127 }
128 });
129 return cnt;
130 }
131
137 static void PerVertexFromTetra(MeshType & m)
138 {
139 RequirePerTetraColor(m);
140 RequirePerVertexColor(m);
141
142 ColorAvgInfo csi;
143 SimpleTempData<typename MeshType::VertContainer, ColorAvgInfo> TD(m.vert, csi);
144
145 ForEachTetra(m, [&] (TetraType & t) {
146 for (int i = 0; i < 4; ++i)
147 {
148 TD[t.V(i)].r += t.C()[0];
149 TD[t.V(i)].g += t.C()[1];
150 TD[t.V(i)].b += t.C()[2];
151 TD[t.V(i)].a += t.C()[3];
152 TD[t.V(i)].cnt += 1;
153 }
154 });
155
156 ForEachVertex(m, [&] (VertexType & v) {
157 v.C()[0] = TD[v].r / TD[v].cnt;
158 v.C()[1] = TD[v].g / TD[v].cnt;
159 v.C()[2] = TD[v].b / TD[v].cnt;
160 v.C()[3] = TD[v].a / TD[v].cnt;
161 });
162 }
163
169 static void PerVertexFromFace( MeshType &m)
170 {
171 RequirePerFaceColor(m);
172 RequirePerVertexColor(m);
173
174 ColorAvgInfo csi;
175 SimpleTempData<typename MeshType::VertContainer, ColorAvgInfo> TD(m.vert,csi);
176
177 FaceIterator fi;
178 for(fi=m.face.begin();fi!=m.face.end();++fi)
179 if(!(*fi).IsD())
180 for(int j=0;j<3;++j)
181 {
182 TD[(*fi).V(j)].r+=(*fi).C()[0];
183 TD[(*fi).V(j)].g+=(*fi).C()[1];
184 TD[(*fi).V(j)].b+=(*fi).C()[2];
185 TD[(*fi).V(j)].a+=(*fi).C()[3];
186 ++TD[(*fi).V(j)].cnt;
187 }
188
189 VertexIterator vi;
190 for(vi=m.vert.begin();vi!=m.vert.end();++vi)
191 if(!(*vi).IsD() && TD[*vi].cnt>0 )
192 {
193 (*vi).C()[0] = TD[*vi].r / TD[*vi].cnt;
194 (*vi).C()[1] = TD[*vi].g / TD[*vi].cnt;
195 (*vi).C()[2] = TD[*vi].b / TD[*vi].cnt;
196 (*vi).C()[3] = TD[*vi].a / TD[*vi].cnt;
197 }
198 }
199
203 static void PerFaceFromVertex( MeshType &m)
204 {
205 RequirePerFaceColor(m);
206 RequirePerVertexColor(m);
207
208 FaceIterator fi;
209 for(fi=m.face.begin();fi!=m.face.end();++fi) if(!(*fi).IsD())
210 {
211 Color4f avg = (Color4f::Construct((*fi).V(0)->C()) +
212 Color4f::Construct((*fi).V(1)->C()) +
213 Color4f::Construct((*fi).V(2)->C()) )/ 3.0;
214 (*fi).C().Import(avg);
215 }
216 }
217
222 static void PerVertexQualityRamp(MeshType &m, ScalarType minq = 0., ScalarType maxq = 0., vcg::ColorMap cmap = vcg::ColorMap::RGB)
223 {
224 RequirePerVertexQuality(m);
225 RequirePerVertexColor(m);
226
227 if(minq == maxq)
228 {
229 std::pair<ScalarType, ScalarType> minmax = Stat<MeshType>::ComputePerVertexQualityMinMax(m);
230 minq=minmax.first;
231 maxq=minmax.second;
232 }
233 for(VertexIterator vi=m.vert.begin();vi!=m.vert.end();++vi)
234 if(!(*vi).IsD()) {
235 (*vi).C() = vcg::GetColorMapping((*vi).Q(), minq, maxq, cmap);
236 }
237 }
238
239
244 static void PerVertexQualityRampParula(MeshType &m, ScalarType minq = 0., ScalarType maxq = 0.)
245 {
246 RequirePerVertexQuality(m);
247 RequirePerVertexColor(m);
248
249 if(minq == maxq)
250 {
251 std::pair<ScalarType, ScalarType> minmax = Stat<MeshType>::ComputePerVertexQualityMinMax(m);
252 minq=minmax.first;
253 maxq=minmax.second;
254 }
255 for(VertexIterator vi = m.vert.begin(); vi != m.vert.end(); ++vi)
256 if(!(*vi).IsD())
257 (*vi).C().SetColorRampParula(minq, maxq, (*vi).Q());
258 }
259
264 static void PerTetraQualityRamp(MeshType &m, ScalarType minq = 0., ScalarType maxq = 0., bool selected = false, vcg::ColorMap cmap = vcg::ColorMap::RGB)
265 {
266 RequirePerTetraColor(m);
267 RequirePerTetraQuality(m);
268
269 if(minq == maxq)
270 {
271 std::pair<ScalarType, ScalarType> minmax = Stat<MeshType>::ComputePerTetraQualityMinMax(m);
272 minq=minmax.first;
273 maxq=minmax.second;
274 }
275
276 ForEachTetra(m, [&] (TetraType & t){
277 if (!selected || t.IsS())
278 t.C() = vcg::GetColorMapping(t.Q(), minq, maxq, cmap);
279 });
280 }
285 static void PerFaceQualityRamp(MeshType &m, ScalarType minq = 0, ScalarType maxq = 0, bool selected = false, vcg::ColorMap cmap = vcg::ColorMap::RGB)
286 {
287 RequirePerFaceColor(m);
288 RequirePerFaceQuality(m);
289
290 if(minq == maxq)
291 {
292 std::pair<ScalarType, ScalarType> minmax = Stat<MeshType>::ComputePerFaceQualityMinMax(m);
293 minq=minmax.first;
294 maxq=minmax.second;
295 }
296 for(FaceIterator fi = m.face.begin();fi != m.face.end(); ++fi)
297 if(!(*fi).IsD())
298 if(!selected || (*fi).IsS())
299 (*fi).C() = vcg::GetColorMapping((*fi).Q(), minq, maxq, cmap);
300 }
301
306 static void PerEdgeQualityRamp(MeshType &m, ScalarType minq = 0, ScalarType maxq = 0, bool selected = false, vcg::ColorMap cmap = vcg::ColorMap::RGB)
307 {
308 RequirePerEdgeColor(m);
309 RequirePerEdgeQuality(m);
310
311 if(minq == maxq)
312 {
313 std::pair<ScalarType, ScalarType> minmax = Stat<MeshType>::ComputePerEdgeQualityMinMax(m);
314 minq=minmax.first;
315 maxq=minmax.second;
316 }
317 for(EdgeIterator ei=m.edge.begin();ei!=m.edge.end();++ei) if(!(*ei).IsD())
318 if(!selected || (*ei).IsS())
319 (*ei).C() = vcg::GetColorMapping((*ei).Q(), minq, maxq, cmap);
320 }
321
326 static void PerVertexQualityGray(MeshType &m, ScalarType minq = 0, ScalarType maxq = 0)
327 {
328 RequirePerVertexColor(m);
329 RequirePerVertexQuality(m);
330 if(minq==maxq)
331 {
332 std::pair<ScalarType, ScalarType> minmax = Stat<MeshType>::ComputePerVertexQualityMinMax(m);
333 minq=minmax.first;
334 maxq=minmax.second;
335 }
336 for(VertexIterator vi=m.vert.begin();vi!=m.vert.end();++vi)
337 if(!(*vi).IsD())
338 (*vi).C().SetGrayShade( ((*vi).Q()-minq)/(maxq-minq));
339 }
340
345 static void PerFaceQualityGray(MeshType &m, ScalarType minq = 0, ScalarType maxq = 0)
346 {
347 RequirePerFaceColor(m);
348 RequirePerFaceQuality(m);
349
350 if(minq==maxq)
351 {
352 std::pair<ScalarType, ScalarType> minmax = Stat<MeshType>::ComputePerFaceQualityMinMax(m);
353 minq=minmax.first;
354 maxq=minmax.second;
355 }
356 for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi) if(!(*fi).IsD())
357 (*fi).C().SetGrayShade( ((*fi).Q()-minq)/(maxq-minq));
358 }
359
371 static void PerVertexBorderFlag( MeshType &m, Color4b BorderColor=Color4b::Blue, Color4b InternalColor=Color4b::White, Color4b MixColor=Color4b::Cyan)
372 {
373 RequirePerVertexColor(m);
374
375 Color4b BaseColor = Color4b::Green;
376
377 PerVertexConstant(m,BaseColor);
378 for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi) if(!(*fi).IsD())
379 for(int j=0;j<3;++j)
380 {
381 if((*fi).IsB(j)){
382 if( (*fi).V(j)->C() == BaseColor) (*fi).V(j)->C() = BorderColor;
383 if( (*fi).V(j)->C() == InternalColor) (*fi).V(j)->C() = MixColor;
384 if( (*fi).V1(j)->C() == BaseColor) (*fi).V1(j)->C() = BorderColor;
385 if( (*fi).V1(j)->C() == InternalColor) (*fi).V1(j)->C() = MixColor;
386 } else
387 {
388 if( (*fi).V(j)->C() == BaseColor) (*fi).V(j)->C() = InternalColor;
389 if( (*fi).V(j)->C() == BorderColor) (*fi).V(j)->C() = MixColor;
390 if( (*fi).V1(j)->C() == BaseColor) (*fi).V1(j)->C() = InternalColor;
391 if( (*fi).V1(j)->C() == BorderColor) (*fi).V1(j)->C() = MixColor;
392 }
393 }
394
395 }
396
401 static void PerFaceRandomConnectedComponent( MeshType &m)
402 {
403 RequirePerFaceColor(m);
404 RequireFFAdjacency(m);
405
406 std::vector< std::pair<int, typename MeshType::FacePointer> > CCV;
407 int ScatterSize= std::min (100,tri::Clean<MeshType>::ConnectedComponents(m, CCV)); // number of random color to be used. Never use too many.
408
409 ConnectedComponentIterator<MeshType> ci;
410 for(unsigned int i=0;i<CCV.size();++i)
411 {
412 Color4b BaseColor = Color4b::Scatter(ScatterSize, i%ScatterSize,.4f,.7f);
413 std::vector<typename MeshType::FacePointer> FPV;
414 for(ci.start(m,CCV[i].second);!ci.completed();++ci)
415 (*ci)->C()=BaseColor;
416 }
417 }
418
423 static void PerFaceRandom(MeshType &m)
424 {
425 RequirePerFaceColor(m);
426 FaceIterator fi;
427 Color4b BaseColor = Color4b::Black;
428 PerFaceConstant(m,BaseColor);
429 int id_num=0;
430 for(fi=m.face.begin();fi!=m.face.end();++fi)
431 if(!(*fi).IsD())
432 {
433 id_num++;
434 if((*fi).C() == BaseColor) (*fi).C() = Color4b::Scatter(50, id_num%50,.4f,.7f);
435 for(int j=0;j<3;++j)
436 if((*fi).IsF(j))
437 {
438 assert(!IsBorder((*fi),j));
439 (*fi).FFp(j)->C()= (*fi).C();
440 }
441 }
442 }
443
450 static void PerVertexPerlinNoise(MeshType& m, CoordType period, CoordType offset = CoordType(0, 0, 0), bool onSelected = false)
451 {
452 RequirePerVertexColor(m);
453
454 CoordType p[3];
455
456 for(VertexIterator vi = m.vert.begin(); vi!=m.vert.end(); ++vi)
457 if(!(*vi).IsD())
458 if ((!onSelected) || ((*vi).IsS()))
459 {
460 // perlin noise is defined in 022
461 p[0] = (vi->P()/period[0])+offset;
462 p[1] = (vi->P()/period[1])+offset;
463 p[2] = (vi->P()/period[2])+offset;
464 (*vi).C() = Color4b( int(127+128.0*math::Perlin::Noise(p[0][0],p[0][1],p[0][2])),
465 int(127+128.0*math::Perlin::Noise(p[1][0],p[1][1],p[1][2])),
466 int(127+128.0*math::Perlin::Noise(p[2][0],p[2][1],p[2][2])),
467 255 );
468 }
469
470 }
471
472
477 static void PerVertexPerlinColoring(MeshType& m, ScalarType period, CoordType offset = CoordType(0, 0, 0), Color4b color1 = Color4b::Black, Color4b color2 = Color4b::White, bool onSelected = false)
478 {
479 RequirePerVertexColor(m);
480
481 CoordType p;
482
483 for (VertexIterator vi = m.vert.begin(); vi != m.vert.end(); ++vi)
484 if (!(*vi).IsD())
485 if ((!onSelected) || ((*vi).IsS()))
486 {
487 // perlin noise is defined in 022
488 p = (vi->P() / period) + offset;
489 double factor = (math::Perlin::Noise(p[0], p[1], p[2]) + 1.0) / 2.0;
490
491 int rr = (color1[0] * factor) + (color2[0] * (1.0 - factor));
492 int gg = (color1[1] * factor) + (color2[1] * (1.0 - factor));
493 int bb = (color1[2] * factor) + (color2[2] * (1.0 - factor));
494 int aa = (color1[3] * factor) + (color2[3] * (1.0 - factor));
495
496 (*vi).C() = Color4b(rr, gg, bb, aa);
497 }
498 }
499
503 static void PerVertexAddNoise(MeshType& m, int noiseBits, bool onSelected=false)
504 {
505 RequirePerVertexColor(m);
506
507 if(noiseBits>8) noiseBits = 8;
508 if(noiseBits<1) return;
509
510 math::SubtractiveRingRNG randomGen = math::SubtractiveRingRNG(time(NULL));
511 for(VertexIterator vi = m.vert.begin(); vi!=m.vert.end(); ++vi)
512 if(!(*vi).IsD())
513 if ((!onSelected) || ((*vi).IsS()))
514 {
515 (*vi).C()[0] = math::Clamp<int>((*vi).C()[0] + randomGen.generate(int(2*pow(2.0f,noiseBits))) - int(pow(2.0f,noiseBits)),0,255);
516 (*vi).C()[1] = math::Clamp<int>((*vi).C()[1] + randomGen.generate(int(2*pow(2.0f,noiseBits))) - int(pow(2.0f,noiseBits)),0,255);
517 (*vi).C()[2] = math::Clamp<int>((*vi).C()[2] + randomGen.generate(int(2*pow(2.0f,noiseBits))) - int(pow(2.0f,noiseBits)),0,255);
518 }
519
520 }
521
522
525 static int PerVertexThresholding(MeshType &m, float threshold, const Color4b c1 = Color4<unsigned char>::Black, const Color4b c2 = Color4<unsigned char>::White, const bool ProcessSelected=false)
526 {
527 RequirePerVertexColor(m);
528
529 int counter=0;
530 VertexIterator vi;
531 for(vi=m.vert.begin();vi!=m.vert.end();++vi) //scan all the vertex...
532 {
533 if(!(*vi).IsD()) //if it has not been deleted...
534 {
535 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
536 {
537 float value = ComputeLightness((*vi).C());
538
539 if(value<=threshold) (*vi).C() = c1;
540 else (*vi).C() = c2;
541 ++counter;
542 }
543 }
544 }
545 return counter;
546 }
547
548 // Computes the lightness value for a specified color. lightness = 0.5*(Max(R,G,B)+Min(R,G,B))
549 static float ComputeLightness(Color4b c)
550 {
551 float min_rgb = (float)math::Min(c[0],c[1],c[2]);
552 float max_rgb = (float)math::Max(c[0],c[1],c[2]);
553 return (max_rgb + min_rgb)/2;
554 }
555
558 static int PerVertexBrightness(MeshType &m, float amount, const bool ProcessSelected=false)
559 {
560 RequirePerVertexColor(m);
561
562 int counter=0;
563 VertexIterator vi;
564 for(vi=m.vert.begin();vi!=m.vert.end();++vi) //scan all the vertex...
565 {
566 if(!(*vi).IsD()) //if it has not been deleted...
567 {
568 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
569 {
570 (*vi).C() = Color4b(
571 math::Clamp(int((*vi).C()[0]+amount),0,255),
572 math::Clamp(int((*vi).C()[1]+amount),0,255),
573 math::Clamp(int((*vi).C()[2]+amount),0,255),
574 255);
575 ++counter;
576 }
577 }
578 }
579 return counter;
580 }
581
584 static int PerVertexContrast(MeshType &m, float factor, const bool ProcessSelected=false)
585 {
586 RequirePerVertexColor(m);
587
588 int counter=0;
589 VertexIterator vi;
590 for(vi=m.vert.begin();vi!=m.vert.end();++vi) //scan all the vertex...
591 {
592 if(!(*vi).IsD()) //if it has not been deleted...
593 {
594 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
595 {
596 (*vi).C() = ColorMul((*vi).C(),factor);
597 ++counter;
598 }
599 }
600 }
601 return counter;
602 }
603
604 //Performs contrast operations on color, i.e expands or compress the histogram around
605 //the midpoint value. NewValue = (OldValue - 128) â—Š factor + 128
606 static Color4b ColorMul(Color4b c, float factor)
607 {
608 return Color4b( ValueMul(c[0], factor), ValueMul(c[1], factor), ValueMul(c[2], factor), 1);
609 }
610
611 static int ValueMul(int value, float factor)
612 {
613 return math::Clamp<int>((int)((value - 128)*factor + 128), 0, 255);
614 }
615
624 static int PerVertexBrightnessContrast(MeshType &m, float brightness, float contrast, const bool ProcessSelected=false)
625 {
626 RequirePerVertexColor(m);
627
628 int counter=0;
629 VertexIterator vi;
630 for(vi=m.vert.begin();vi!=m.vert.end();++vi) //scan all the vertex...
631 {
632 if(!(*vi).IsD()) //if it has not been deleted...
633 {
634 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
635 {
636 (*vi).C() = ColorBrightnessContrast((*vi).C(),brightness,contrast);
637 ++counter;
638 }
639 }
640 }
641 return counter;
642 }
643
644 static Color4b ColorBrightnessContrast(Color4b c, float brightness, float contrast)
645 {
646 return Color4b( ValueBrightnessContrast(c[0], brightness, contrast),
647 ValueBrightnessContrast(c[1], brightness, contrast),
648 ValueBrightnessContrast(c[2], brightness, contrast), 1 );
649 }
650
651 static int ValueBrightnessContrast(unsigned char ivalue, float brightness, float contrast)
652 {
653 float value = float(ivalue)/255.0f;
654 if (brightness < 0.0) value = value * ( 1.0 + brightness);
655 else value = value + ((1.0 - value) * brightness);
656 value = (value - 0.5) * (tan ((contrast + 1) * M_PI/4) ) + 0.5;
657 return math::Clamp<int>(255.0*value, 0, 255);
658 }
659
664 static int PerVertexInvert(MeshType &m, const bool ProcessSelected=false)
665 {
666 RequirePerVertexColor(m);
667
668 int counter=0;
669 for(VertexIterator vi=m.vert.begin(); vi!=m.vert.end(); ++vi) //scan all the vertex...
670 {
671 if(!(*vi).IsD()) //if it has not been deleted...
672 {
673 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
674 {
675 Color4b &c=(*vi).C();
676 c=Color4b( 255-c[0],255-c[1],255-c[2], 1);
677 ++counter;
678 }
679 }
680 }
681 return counter;
682 }
683
687 static int PerVertexGamma(MeshType &m, float gamma, const bool ProcessSelected=false)
688 {
689 RequirePerVertexColor(m);
690
691 int counter=0;
692
693 VertexIterator vi;
694 for(vi=m.vert.begin();vi!=m.vert.end();++vi) //scan all the vertex...
695 {
696 if(!(*vi).IsD()) //if it has not been deleted...
697 {
698 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
699 {
700 (*vi).C() = ColorPow((*vi).C(), 1/gamma);
701 ++counter;
702 }
703 }
704 }
705 return counter;
706 }
707
708 //computes the standard gamma transformation on a given color, according to NewVal = OldVal^(1/gamma)
709 static Color4b ColorPow(Color4b c, float exponent)
710 {
711 return vcg::Color4b(
712 math::Clamp((int)( ValuePow(float(c[0])/255, exponent)*255), 0, 255),
713 math::Clamp((int)( ValuePow(float(c[1])/255, exponent)*255), 0, 255),
714 math::Clamp((int)( ValuePow(float(c[2])/255, exponent)*255), 0, 255),
715 255);
716 }
717
718 static float ValuePow(float value, float exponent)
719 {
720 return powf(value, exponent);
721 }
722
723 //useful bit masks for RGB channels, used for Levels filter.
724 enum rgbChMask {ALL_CHANNELS = 7, RED_CHANNEL = 4, GREEN_CHANNEL = 2, BLUE_CHANNEL = 1, NO_CHANNELS = 0 };
725
734 static int PerVertexLevels(MeshType &m, float gamma, float in_min, float in_max, float out_min, float out_max, unsigned char rgbMask, const bool ProcessSelected=false)
735 {
736 RequirePerVertexColor(m);
737
738 int counter=0;
739 VertexIterator vi;
740 for(vi=m.vert.begin();vi!=m.vert.end();++vi) //scan all the vertex...
741 {
742 if(!(*vi).IsD()) //if it has not been deleted...
743 {
744 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
745 {
746 (*vi).C() = ColorLevels((*vi).C(), gamma, in_min, in_max, out_min, out_max, rgbMask);
747 ++counter;
748 }
749 }
750 }
751 return counter;
752 }
753
754 //Performs levels transformation on each channel set to 1 in the rgbMask.
755 static Color4b ColorLevels(Color4b c, float gamma, float in_min, float in_max, float out_min, float out_max, unsigned char rgbMask)
756 {
757 unsigned char r = c[0], g = c[1], b = c[2];
758 if(rgbMask & RED_CHANNEL) r = ValueLevels(c[0], gamma, in_min, in_max, out_min, out_max);
759 if(rgbMask & GREEN_CHANNEL) g = ValueLevels(c[1], gamma, in_min, in_max, out_min, out_max);
760 if(rgbMask & BLUE_CHANNEL) b = ValueLevels(c[2], gamma, in_min, in_max, out_min, out_max);
761 return Color4b(r, g, b, 255);
762 }
763
764 //Transform on levels
765 static int ValueLevels(int value, float gamma, float in_min, float in_max, float out_min, float out_max)
766 {
767 float fvalue = value/255.0f;
768 // normalize
769 fvalue = math::Clamp<float>(fvalue - in_min, 0.0f, 1.0f) / math::Clamp<float>(in_max - in_min, 1.0f/255.0f, 1.0f);
770 // transform gamma
771 fvalue = powf(fvalue,1/gamma);
772 // rescale range
773 fvalue = fvalue * (out_max - out_min) + out_min;
774 //back in interval [0,255] and clamp
775 return math::Clamp<int>((int)(fvalue * 255), 0, 255);
776 }
777
783 static int PerVertexColourisation(MeshType &m, Color4b c, float intensity, const bool ProcessSelected=false)
784 {
785 RequirePerVertexColor(m);
786
787 int counter=0;
788 VertexIterator vi;
789 for(vi=m.vert.begin();vi!=m.vert.end();++vi)
790 {
791 if(!(*vi).IsD()) //if it has not been deleted...
792 {
793 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
794 {
795 (*vi).C() = ColorApplyDiff((*vi).C(), c, intensity);
796 ++counter;
797 }
798 }
799 }
800 return counter;
801 }
802
803 // Perform colourisation operation.
804 // For each channel C:
805 // newC = origC + intensity * (newC - origC)
806 static Color4b ColorApplyDiff(Color4b old_color, Color4b new_color, float intensity)
807 {
808 return Color4b( ValueApplyDiff(old_color[0], new_color[0], intensity),
809 ValueApplyDiff(old_color[1], new_color[1], intensity),
810 ValueApplyDiff(old_color[2], new_color[2], intensity), 255);
811 }
812
813 static int ValueApplyDiff(int old_value, int new_value, float intensity)
814 {
815 return math::Clamp<int>((int)(old_value + intensity * (new_value - old_value)), 0, 255);
816 }
817
818 //An useful ENUM to hold all desaturation methods.
819 enum DesaturationMethods {M_LIGHTNESS = 0, M_LUMINOSITY = 1, M_AVERAGE = 2};
820
830 static int PerVertexDesaturation(MeshType &m, int method, const bool ProcessSelected=false)
831 {
832 RequirePerVertexColor(m);
833
834 int counter=0;
835 VertexIterator vi;
836 for(vi=m.vert.begin();vi!=m.vert.end();++vi) //scan all the vertex...
837 {
838 if(!(*vi).IsD()) //if it has not been deleted...
839 {
840 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
841 {
842 (*vi).C() = ColorDesaturate((*vi).C(), method);
843 ++counter;
844 }
845 }
846 }
847 return counter;
848 }
849
850 //Desature the color. Ausiliary functions to calculate lightness/luminosity/average.
851 static Color4b ColorDesaturate(Color4b c, int method)
852 {
853 switch(method){
854 case M_LIGHTNESS:{
855 int val = (int)ComputeLightness(c);
856 return Color4b( val, val, val, 255);
857 }
858 case M_AVERAGE:{
859 int val = (int)ComputeAvgLightness(c);
860 return Color4b( val, val, val, 255);
861 }
862 case M_LUMINOSITY:{
863 int val = (int)ComputeLuminosity(c);
864 return Color4b( val, val, val, 255);
865 }
866 default: assert(0);
867 }
868 return Color4b(255, 255, 255, 255);
869 }
870
871 //ausiliary function to compute average lightness. value = (R+G+B)/3
872 static float ComputeAvgLightness(Color4b c)
873 {
874 return float(c[0]+c[1]+c[2])/3.0f;
875 }
876
877 //ausiliary function to compute luminosity. value = 0.21*R+0.71*G+0.7*B
878 static float ComputeLuminosity(Color4b c)
879 {
880 return float(0.2126f*c[0]+0.7152f*c[1]+0.0722f*c[2]);
881 }
882
888 static int PerVertexEqualize(MeshType &m, unsigned int rgbMask, const bool ProcessSelected=false)
889 {
890 RequirePerVertexColor(m);
891
892 //declares , resets and set up 4 histograms, for Red, Green, Blue and Lightness
893 Histogramf Hl, Hr, Hg, Hb;
894 Hl.Clear(); Hr.Clear(); Hg.Clear(); Hb.Clear();
895 Hl.SetRange(0, 255, 255); Hr.SetRange(0, 255, 255); Hg.SetRange(0, 255, 255); Hb.SetRange(0, 255, 255);
896
897 int counter=0;
898 VertexIterator vi;
899
900 //Scan the mesh to build the histograms
901 for(vi=m.vert.begin();vi!=m.vert.end();++vi) //scan all the vertex...
902 {
903 if(!(*vi).IsD()) //if it has not been deleted...
904 {
905 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, put it in the histograms
906 {
907 float v = ComputeLightness((*vi).C())+0.5; //compute and round lightness value
908 Hl.Add(v); Hr.Add((float)(*vi).C()[0]); Hg.Add((float)(*vi).C()[1]); Hb.Add((float)(*vi).C()[2]);
909 }
910 }
911 }
912
913 //for each histogram, compute the cumulative distribution function, and build a lookup table
914 int cdf_l[256], cdf_r[256], cdf_g[256], cdf_b[256];
915 cdf_l[0] = Hl.BinCount(0); cdf_r[0] = Hr.BinCount(0); cdf_g[0] = Hg.BinCount(0); cdf_b[0] = Hb.BinCount(0);
916 for(int i=1; i<256; i++){
917 cdf_l[i] = Hl.BinCount(float(i)) + cdf_l[i-1];
918 cdf_r[i] = Hr.BinCount(float(i)) + cdf_r[i-1];
919 cdf_g[i] = Hg.BinCount(float(i)) + cdf_g[i-1];
920 cdf_b[i] = Hb.BinCount(float(i)) + cdf_b[i-1];
921 }
922
923 //this loop aaplies the transformation to colors
924 for(vi=m.vert.begin();vi!=m.vert.end();++vi) //scan all the vertex...
925 {
926 if(!(*vi).IsD()) //if it has not been deleted...
927 {
928 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
929 {
930 (*vi).C()=ColorEqualize((*vi).C(), cdf_l, cdf_r, cdf_g, cdf_b, rgbMask);
931 ++counter;
932 }
933 }
934 }
935 return counter;
936 }
937
938 //Applies equalization to the components of the color according to rgbmask
939 static Color4b ColorEqualize(Color4b c, int cdf_l[256], int cdf_r[256], int cdf_g[256], int cdf_b[256], unsigned int rgbMask)
940 {
941 unsigned char r = c[0], g = c[1], b = c[2];
942 if(rgbMask == NO_CHANNELS) //in this case, equalization is done on lightness
943 {
944 int v = ValueEqualize(cdf_l[(int)(ComputeLightness(c)+0.5f)], cdf_l[0], cdf_l[255]);
945 return Color4b(v, v, v, 255); //return the equalized gray color
946 }
947 if(rgbMask & RED_CHANNEL) r = ValueEqualize(cdf_r[c[0]], cdf_r[0], cdf_r[255]); //Equalizes red
948 if(rgbMask & GREEN_CHANNEL) g = ValueEqualize(cdf_g[c[1]], cdf_g[0], cdf_g[255]); //Equalizes green
949 if(rgbMask & BLUE_CHANNEL) b = ValueEqualize(cdf_b[c[2]], cdf_b[0], cdf_b[255]); //Equalizes blue
950 return Color4b(r, g, b, 255); //return the equalized color
951 }
952
953 //Compute the equalized value
954 static int ValueEqualize(int cdfValue, int cdfMin, int cdfMax)
955 {
956 return int(float((cdfValue - cdfMin)/float(cdfMax - cdfMin)) * 255.0f);
957 }
958
964 static int PerVertexWhiteBalance(MeshType &m, Color4b userColor, const bool ProcessSelected=false)
965 {
966 RequirePerVertexColor(m);
967
968 Color4b unbalancedWhite= userColor;
969 int counter=0;
970 VertexIterator vi;
971
972 //in this loop the transformation is applied to the mesh
973 for(vi=m.vert.begin();vi!=m.vert.end();++vi) //scan all the vertex...
974 {
975 if(!(*vi).IsD()) //if it has not been deleted...
976 {
977 if(!ProcessSelected || (*vi).IsS()) //if this vertex has been selected, do transormation
978 {
979 (*vi).C()=ColorWhiteBalance((*vi).C(),unbalancedWhite);
980 ++counter;
981 }
982 }
983 }
984 return counter;
985 }
986
987 //Balnce the white of the color, applying a correction factor based on the unbalancedWhite color.
988 static Color4b ColorWhiteBalance(Color4b c, Color4b unbalancedWhite)
989 {
990 //sanity check to avoid division by zero...
991 if(unbalancedWhite[0]==0) unbalancedWhite[0]=1;
992 if(unbalancedWhite[1]==0) unbalancedWhite[1]=1;
993 if(unbalancedWhite[2]==0) unbalancedWhite[2]=1;
994
995 return Color4b(
996 math::Clamp<int>((int)(c[0]*(255.0f/unbalancedWhite[0])), 0, 255),
997 math::Clamp<int>((int)(c[1]*(255.0f/unbalancedWhite[1])), 0, 255),
998 math::Clamp<int>((int)(c[2]*(255.0f/unbalancedWhite[2])), 0, 255),
999 255);
1000 }
1001
1002};
1003
1004}// end namespace
1005}// end namespace
1006#endif
vcg::Color4
Definition: color4.h:41
vcg::Color4::Scatter
static Color4 Scatter(int range, int value, float Sat=.3f, float Val=.9f)
Definition: color4.h:233
vcg::tri::Clean
Class of static functions to clean//restore meshs.
Definition: clean.h:165
vcg::tri::UpdateColor
Generation and processing of per-vertex and per-face colors according to various strategy.
Definition: color.h:54
vcg::tri::UpdateColor::PerVertexEqualize
static int PerVertexEqualize(MeshType &m, unsigned int rgbMask, const bool ProcessSelected=false)
Histogram Color Equalization.
Definition: color.h:888
vcg::tri::UpdateColor::PerFaceQualityGray
static void PerFaceQualityGray(MeshType &m, ScalarType minq=0, ScalarType maxq=0)
This function colores all the faces of a mesh with a gray shade dependent on the quality.
Definition: color.h:345
vcg::tri::UpdateColor::PerVertexBrightnessContrast
static int PerVertexBrightnessContrast(MeshType &m, float brightness, float contrast, const bool ProcessSelected=false)
Apply Brightness and Contrast filter to the mesh, with the given contrast factor and brightness amoun...
Definition: color.h:624
vcg::tri::UpdateColor::PerVertexWhiteBalance
static int PerVertexWhiteBalance(MeshType &m, Color4b userColor, const bool ProcessSelected=false)
Simple white balancing filter.
Definition: color.h:964
vcg::tri::UpdateColor::PerTetraConstant
static int PerTetraConstant(MeshType &m, Color4b vs=Color4b::White, bool selected=false)
This function colors all (or the selected) tetras of a mesh.
Definition: color.h:118
vcg::tri::UpdateColor::PerVertexBrightness
static int PerVertexBrightness(MeshType &m, float amount, const bool ProcessSelected=false)
Apply the brightness filter, with the given amount, to the mesh.
Definition: color.h:558
vcg::tri::UpdateColor::PerVertexQualityGray
static void PerVertexQualityGray(MeshType &m, ScalarType minq=0, ScalarType maxq=0)
This function colores all the vertices of a mesh with a gray shade dependent on the quality.
Definition: color.h:326
vcg::tri::UpdateColor::PerVertexBorderFlag
static void PerVertexBorderFlag(MeshType &m, Color4b BorderColor=Color4b::Blue, Color4b InternalColor=Color4b::White, Color4b MixColor=Color4b::Cyan)
Color the vertexes of the mesh that are on the border.
Definition: color.h:371
vcg::tri::UpdateColor::PerFaceQualityRamp
static void PerFaceQualityRamp(MeshType &m, ScalarType minq=0, ScalarType maxq=0, bool selected=false, vcg::ColorMap cmap=vcg::ColorMap::RGB)
This function colores all the faces of a mesh with a hue color shade dependent on the quality.
Definition: color.h:285
vcg::tri::UpdateColor::PerFaceFromVertex
static void PerFaceFromVertex(MeshType &m)
Transfer vertex color onto face color Plain average of the color of the vertexes on a given face.
Definition: color.h:203
vcg::tri::UpdateColor::PerVertexLevels
static int PerVertexLevels(MeshType &m, float gamma, float in_min, float in_max, float out_min, float out_max, unsigned char rgbMask, const bool ProcessSelected=false)
Adjusts color levels of the mesh.
Definition: color.h:734
vcg::tri::UpdateColor::PerFaceRandomConnectedComponent
static void PerFaceRandomConnectedComponent(MeshType &m)
This function colores the faces of connected components of a mesh randomly.
Definition: color.h:401
vcg::tri::UpdateColor::PerTetraQualityRamp
static void PerTetraQualityRamp(MeshType &m, ScalarType minq=0., ScalarType maxq=0., bool selected=false, vcg::ColorMap cmap=vcg::ColorMap::RGB)
This function colores all the faces of a mesh with a hue color shade dependent on the quality.
Definition: color.h:264
vcg::tri::UpdateColor::PerVertexFromFace
static void PerVertexFromFace(MeshType &m)
Transfer face color onto vertex color.
Definition: color.h:169
vcg::tri::UpdateColor::PerVertexInvert
static int PerVertexInvert(MeshType &m, const bool ProcessSelected=false)
Invert the colors of the mesh.
Definition: color.h:664
vcg::tri::UpdateColor::PerVertexFromTetra
static void PerVertexFromTetra(MeshType &m)
Transfer tetra color onto vertex color.
Definition: color.h:137
vcg::tri::UpdateColor::PerVertexPerlinColoring
static void PerVertexPerlinColoring(MeshType &m, ScalarType period, CoordType offset=CoordType(0, 0, 0), Color4b color1=Color4b::Black, Color4b color2=Color4b::White, bool onSelected=false)
Perlin Color mixing.
Definition: color.h:477
vcg::tri::UpdateColor::PerVertexConstant
static int PerVertexConstant(MeshType &m, Color4b vs=Color4b::White, bool selected=false)
This function colors all (or the selected) the vertices of a mesh.
Definition: color.h:83
vcg::tri::UpdateColor::PerVertexDesaturation
static int PerVertexDesaturation(MeshType &m, int method, const bool ProcessSelected=false)
Desaturates the mesh according the a chosen desaturation method.
Definition: color.h:830
vcg::tri::UpdateColor::PerVertexQualityRampParula
static void PerVertexQualityRampParula(MeshType &m, ScalarType minq=0., ScalarType maxq=0.)
This function colores all the faces of a mesh with a hue color shade dependent on the quality.
Definition: color.h:244
vcg::tri::UpdateColor::PerVertexThresholding
static int PerVertexThresholding(MeshType &m, float threshold, const Color4b c1=Color4< unsigned char >::Black, const Color4b c2=Color4< unsigned char >::White, const bool ProcessSelected=false)
Reduces vertex color the mesh to two colors according to a threshold.
Definition: color.h:525
vcg::tri::UpdateColor::PerEdgeQualityRamp
static void PerEdgeQualityRamp(MeshType &m, ScalarType minq=0, ScalarType maxq=0, bool selected=false, vcg::ColorMap cmap=vcg::ColorMap::RGB)
This function colores all the edges of a mesh with a hue color shade dependent on the quality.
Definition: color.h:306
vcg::tri::UpdateColor::PerVertexGamma
static int PerVertexGamma(MeshType &m, float gamma, const bool ProcessSelected=false)
Apply the gamma correction filter, with the given gamma exponet, to the mesh.
Definition: color.h:687
vcg::tri::UpdateColor::PerVertexContrast
static int PerVertexContrast(MeshType &m, float factor, const bool ProcessSelected=false)
Apply Contrast filter to the mesh with the given contrast factor.
Definition: color.h:584
vcg::tri::UpdateColor::PerVertexPerlinNoise
static void PerVertexPerlinNoise(MeshType &m, CoordType period, CoordType offset=CoordType(0, 0, 0), bool onSelected=false)
Perlin Noise.
Definition: color.h:450
vcg::tri::UpdateColor::PerVertexColourisation
static int PerVertexColourisation(MeshType &m, Color4b c, float intensity, const bool ProcessSelected=false)
Colorize the mesh toward a given color.
Definition: color.h:783
vcg::tri::UpdateColor::PerFaceConstant
static int PerFaceConstant(MeshType &m, Color4b vs=Color4b::White, bool selected=false)
This function colors all (or the selected) faces of a mesh.
Definition: color.h:101
vcg::tri::UpdateColor::PerFaceRandom
static void PerFaceRandom(MeshType &m)
This function colores the face of a mesh randomly.
Definition: color.h:423
vcg::tri::UpdateColor::PerVertexAddNoise
static void PerVertexAddNoise(MeshType &m, int noiseBits, bool onSelected=false)
Simple Noise adding function. It simply add signed noise to the color of the mesh....
Definition: color.h:503
vcg::tri::UpdateColor::PerVertexQualityRamp
static void PerVertexQualityRamp(MeshType &m, ScalarType minq=0., ScalarType maxq=0., vcg::ColorMap cmap=vcg::ColorMap::RGB)
This function colores all the faces of a mesh with a hue color shade dependent on the quality.
Definition: color.h:222
vcg::tri::ForEachTetra
void ForEachTetra(const MeshType &m, Callable action)
Definition: foreach.h:270
vcg::tri::ForEachVertex
void ForEachVertex(const MeshType &m, Callable action)
Definition: foreach.h:126
vcg
Definition: color4.h:30
Generated by doxygen 1.9.6 on Mon Dec 1 2025 17:19:44