Logo ROOT  
Reference Guide
REveBoxSet.cxx
Go to the documentation of this file.
1// @(#)root/eve:$Id$
2// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
3
4/*************************************************************************
5 * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include "ROOT/REveBoxSet.hxx"
13#include "ROOT/REveShape.hxx"
16
17#include "TRandom.h"
18#include <cassert>
19
20#include <nlohmann/json.hpp>
21
22using namespace::ROOT::Experimental;
23
24/** \class REveBoxSet
25\ingroup REve
26Collection of 3D primitives (fixed-size boxes, boxes of different
27sizes, or arbitrary sexto-epipeds, cones). Each primitive can be assigned
28a signal value and a TRef.
29
30A collection of 3D-markers. The way how they are defined depends
31on the fBoxType data-member.
32 - kBT_FreeBox arbitrary box: specify 8*(x,y,z) box corners
33 - kBT_AABox axis-aligned box: specify (x,y,z) and (w, h, d)
34 - kBT_AABoxFixedDim axis-aligned box w/ fixed dimensions: specify (x,y,z)
35 also set fDefWidth, fDefHeight and fDefDepth
36 - kBT_Cone cone defined with position, axis-vector and radius
37 - EllipticCone cone with elliptic base (specify another radius and angle in deg)
38
39Each primitive can be assigned:
40
41 1. Color or signal value. Thresholds and signal-to-color mapping
42 can then be set dynamically via the REveRGBAPalette class.
43 2. External TObject* (stored as TRef).
44
45See also base-class REveDigitSet for more information.
46Tutorial: tutorials/eve/boxset_test.C
47*/
48
49////////////////////////////////////////////////////////////////////////////////
50
51REveBoxSet::REveBoxSet(const char* n, const char* t) :
52 REveDigitSet (n, t),
53
54 fBoxType (kBT_Undef),
55 fDefWidth (1),
56 fDefHeight (1),
57 fDefDepth (1),
58
59 fBoxSkip (0),
60
61 fDrawConeCap (kFALSE)
62{
63 // Constructor.
64
65 // Override from REveDigitSet.
67}
68
69////////////////////////////////////////////////////////////////////////////////
70/// Return size of data-structure describing a box of type bt.
71
73{
74 static const REveException eH("REveBoxSet::SizeofAtom ");
75
76 switch (bt) {
77 case kBT_Undef: return 0;
78 case kBT_FreeBox: return sizeof(BFreeBox_t);
79 case kBT_AABox: return sizeof(BAABox_t);
80 case kBT_AABoxFixedDim: return sizeof(BAABoxFixedDim_t);
81 case kBT_Cone: return sizeof(BCone_t);
82 case kBT_EllipticCone: return sizeof(BEllipticCone_t);
83 case kBT_Hex: return sizeof(BHex_t);
84 default: throw(eH + "unexpected atom type.");
85 }
86 return 0;
87}
88
89////////////////////////////////////////////////////////////////////////////////
90/// Reset the data containers to zero size.
91/// The arguments describe the basic parameters of data storage.
92
93void REveBoxSet::Reset(REveBoxSet::EBoxType_e boxType, Bool_t valIsCol, Int_t chunkSize)
94{
95 fBoxType = boxType;
96 fValueIsColor = valIsCol;
97 fDefaultValue = valIsCol ? 0 : kMinInt;
98 ReleaseIds();
99 fPlex.Reset(SizeofAtom(fBoxType), chunkSize);
100}
101
102////////////////////////////////////////////////////////////////////////////////
103/// Reset the data containers to zero size.
104/// Keep the old data-storage parameters.
105
107{
108 ReleaseIds();
110}
111
112////////////////////////////////////////////////////////////////////////////////
113/// Create a new box from a set of 8 vertices.
114/// To be used for box-type kBT_FreeBox.
115
116void REveBoxSet::AddBox(const Float_t* verts)
117{
118 static const REveException eH("REveBoxSet::AddBox ");
119
120 if (fBoxType != kBT_FreeBox)
121 throw(eH + "expect free box-type.");
122
124 memcpy(b->fVertices, verts, sizeof(b->fVertices));
126}
127
128////////////////////////////////////////////////////////////////////////////////
129/// Create a new axis-aligned box from at a given position and with
130/// specified dimensions.
131/// To be used for box-type kBT_AABox.
132
134{
135 static const REveException eH("REveBoxSet::AddBox ");
136
137 if (fBoxType != kBT_AABox)
138 throw(eH + "expect axis-aligned box-type.");
139
141 box->fA = a; box->fB = b; box->fC = c;
142 box->fW = w; box->fH = h; box->fD = d;
143}
144
145////////////////////////////////////////////////////////////////////////////////
146/// Create a new axis-aligned box from at a given position.
147/// To be used for box-type kBT_AABoxFixedDim.
148
150{
151 static const REveException eH("REveBoxSet::AddBox ");
152
154 throw(eH + "expect axis-aligned fixed-dimension box-type.");
155
157 box->fA = a; box->fB = b; box->fC = c;
158}
159
160////////////////////////////////////////////////////////////////////////////////
161/// Create a cone with apex at pos, axis dir and radius r.
162/// To be used for box-type kBT_Cone.
163
164void REveBoxSet::AddCone(const REveVector& pos, const REveVector& dir, Float_t r)
165{
166 static const REveException eH("REveBoxSet::AddCone ");
167
168 if (fBoxType != kBT_Cone)
169 throw(eH + "expect cone box-type.");
170
171 BCone_t* cone = (BCone_t*) NewDigit();
172 cone->fPos = pos;
173 cone->fDir = dir;
174 cone->fR = r;
175}
176
177////////////////////////////////////////////////////////////////////////////////
178/// Create a cone with apex at pos, axis dir and radius r.
179/// To be used for box-type kBT_EllipticCone.
180
183{
184 static const REveException eH("REveBoxSet::AddEllipticCone ");
185
187 throw(eH + "expect elliptic-cone box-type.");
188
190 cone->fPos = pos;
191 cone->fDir = dir;
192 cone->fR = r;
193 cone->fR2 = r2;
194 cone->fAngle = angle;
195}
196
197////////////////////////////////////////////////////////////////////////////////
198/// Create a hexagonal prism with center of one hexagon at pos, radius of
199/// hexagon vertices r, rotation angle angle (in degrees), and length along z
200/// of depth. To be used for box-type kBT_Hex.
201
203{
204 static const REveException eH("REveBoxSet::AddEllipticCone ");
205
206 if (fBoxType != kBT_Hex)
207 throw(eH + "expect hex box-type.");
208
209 BHex_t* hex = (BHex_t*) NewDigit();
210 hex->fPos = pos;
211 hex->fR = r;
212 hex->fAngle = angle;
213 hex->fDepth = depth;
214}
215
216////////////////////////////////////////////////////////////////////////////////
217/// Fill bounding-box information of the base-class TAttBBox (virtual method).
218/// If member 'REveFrameBox* fFrame' is set, frame's corners are used as bbox.
219
221{
222 static const REveException eH("REveBoxSet::ComputeBBox ");
223
224 if (fFrame != 0)
225 {
226 BBoxInit();
227 Int_t n = fFrame->GetFrameSize() / 3;
228 Float_t *bbps = fFrame->GetFramePoints();
229 for (int i=0; i<n; ++i, bbps+=3)
230 BBoxCheckPoint(bbps);
231 return;
232 }
233
234 if(fPlex.Size() == 0)
235 {
236 BBoxZero();
237 return;
238 }
239
240 BBoxInit();
241
243 switch (fBoxType)
244 {
245
246 case kBT_FreeBox:
247 {
248 while (bi.next()) {
249 BFreeBox_t& b = * (BFreeBox_t*) bi();
250 for (Int_t i = 0; i < 8; ++i)
251 BBoxCheckPoint(b.fVertices[i]);
252 }
253 break;
254 }
255
256 case kBT_AABox:
257 {
258 while (bi.next()) {
259 BAABox_t& b = * (BAABox_t*) bi();
260 BBoxCheckPoint(b.fA, b.fB, b.fC);
261 BBoxCheckPoint(b.fA + b.fW, b.fB + b.fH , b.fC + b.fD);
262 }
263 break;
264 }
265
267 {
268 while (bi.next()) {
270 BBoxCheckPoint(b.fA, b.fB, b.fC);
271 BBoxCheckPoint(b.fA + fDefWidth, b.fB + fDefHeight , b.fC + fDefDepth);
272 }
273 break;
274 }
275
276 case kBT_Cone:
277 {
278 Float_t mag2=0, mag2Max=0, rMax=0;
279 while (bi.next()) {
280 BCone_t& b = * (BCone_t*) bi();
281 BBoxCheckPoint(b.fPos.fX, b.fPos.fY, b.fPos.fZ);
282 mag2 = b.fDir.Mag2();
283 if (mag2>mag2Max) mag2Max=mag2;
284 if (b.fR>rMax) rMax=b.fR;
285 }
286 Float_t off = TMath::Sqrt(mag2Max + rMax*rMax);
287 fBBox[0] -= off;fBBox[2] -= off;fBBox[4] -= off;
288 fBBox[1] += off;fBBox[3] += off;fBBox[5] += off;
289 break;
290 }
291
292 case kBT_EllipticCone:
293 {
294 Float_t mag2=0, mag2Max=0, rMax=0;
295 while (bi.next()) {
296 BEllipticCone_t& b = * (BEllipticCone_t*) bi();
297 BBoxCheckPoint(b.fPos.fX, b.fPos.fY, b.fPos.fZ);
298 mag2 = b.fDir.Mag2();
299 if (mag2>mag2Max) mag2Max=mag2;
300 if (b.fR > rMax) rMax = b.fR;
301 if (b.fR2 > rMax) rMax = b.fR2;
302 }
303 Float_t off = TMath::Sqrt(mag2Max + rMax*rMax);
304 fBBox[0] -= off;fBBox[2] -= off;fBBox[4] -= off;
305 fBBox[1] += off;fBBox[3] += off;fBBox[5] += off;
306 break;
307 }
308
309 case kBT_Hex:
310 {
311 while (bi.next()) {
312 BHex_t& h = * (BHex_t*) bi();
313 BBoxCheckPoint(h.fPos.fX - h.fR, h.fPos.fY - h.fR, h.fPos.fZ);
314 BBoxCheckPoint(h.fPos.fX + h.fR, h.fPos.fY - h.fR, h.fPos.fZ);
315 BBoxCheckPoint(h.fPos.fX + h.fR, h.fPos.fY + h.fR, h.fPos.fZ);
316 BBoxCheckPoint(h.fPos.fX - h.fR, h.fPos.fY + h.fR, h.fPos.fZ);
317 BBoxCheckPoint(h.fPos.fX - h.fR, h.fPos.fY - h.fR, h.fPos.fZ + h.fDepth);
318 BBoxCheckPoint(h.fPos.fX + h.fR, h.fPos.fY - h.fR, h.fPos.fZ + h.fDepth);
319 BBoxCheckPoint(h.fPos.fX + h.fR, h.fPos.fY + h.fR, h.fPos.fZ + h.fDepth);
320 BBoxCheckPoint(h.fPos.fX - h.fR, h.fPos.fY + h.fR, h.fPos.fZ + h.fDepth);
321 }
322 break;
323 }
324
325 default:
326 {
327 throw(eH + "unsupported box-type.");
328 }
329
330 } // end switch box-type
331}
332
333////////////////////////////////////////////////////////////////////////////////
334/// Fill core part of JSON representation.
335
337{
338 Int_t ret = REveDigitSet::WriteCoreJson(j, rnr_offset);
339 j["boxType"] = int(fBoxType);
340
341 return ret;
342}
343
344////////////////////////////////////////////////////////////////////////////////
345/// Creates 3D point array for rendering.
346
348{
349 fRenderData = std::make_unique<REveRenderData>("makeBoxSet", fPlex.Size() * 24, 0, fPlex.Size());
350
352 while (bi.next()) {
354 if (IsDigitVisible(b)) {
356 if (fSingleColor == false) {
357
358 if (fValueIsColor) {
359 fRenderData->PushI(int(b->fValue));
360 } else if (fSingleColor == false) {
361 UChar_t c[4] = {0, 0, 0, 0};
363
364 int value = c[0] + c[1] * 256 + c[2] * 256 * 256;
365
366 // printf("box val [%d] values (%d, %d, %d) -> int <%d>\n", b.fValue, c[0], c[1], c[2], value);
367 fRenderData->PushI(value);
368 }
369 }
370 }
371 }
372}
373
374////////////////////////////////////////////////////////////////////////////////
375/// Write shape data for different cases
376///
378{
379 switch (fBoxType) {
382 // vertices
383 for (int c = 0; c < 8; c++) {
384 for (int j = 0; j < 3; j++)
385 fRenderData->PushV(b.fVertices[c][j]);
386 }
387 break;
388 }
389
392 // position
393 fRenderData->PushV(b.fA, b.fB, b.fC);
394 // dimensions
395 fRenderData->PushV(b.fW, b.fH, b.fD);
396
397 break;
398 }
399 default: assert(false && "REveBoxSet::BuildRenderData only kBT_FreeBox type supported");
400 }
401}
402
403////////////////////////////////////////////////////////////////////////////////
404/// Fill the structure with a random set of boxes.
405
407{
408 Reset(kBT_AABox, kTRUE, nboxes);
409 TRandom rnd(0);
410 const Float_t origin = 10, size = 2;
411 Int_t color;
412 for(Int_t i=0; i<nboxes; ++i)
413 {
414 AddBox(origin * rnd.Uniform(-1, 1),
415 origin * rnd.Uniform(-1, 1),
416 origin * rnd.Uniform(-1, 1),
417 size * rnd.Uniform(0.1, 1),
418 size * rnd.Uniform(0.1, 1),
419 size * rnd.Uniform(0.1, 1));
420
421 REveUtil::ColorFromIdx(rnd.Integer(256), (UChar_t*)&color);
422 DigitValue(color);
423 }
424}
#define d(i)
Definition: RSha256.hxx:102
#define c(i)
Definition: RSha256.hxx:101
#define h(i)
Definition: RSha256.hxx:106
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
const Int_t kMinInt
Definition: RtypesCore.h:113
unsigned char UChar_t
Definition: RtypesCore.h:38
const Bool_t kFALSE
Definition: RtypesCore.h:101
float Float_t
Definition: RtypesCore.h:57
const Bool_t kTRUE
Definition: RtypesCore.h:100
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t b
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint angle
void AddEllipticCone(const REveVector &pos, const REveVector &dir, Float_t r, Float_t r2, Float_t angle=0)
Create a cone with apex at pos, axis dir and radius r.
Definition: REveBoxSet.cxx:181
void ComputeBBox() override
Fill bounding-box information of the base-class TAttBBox (virtual method).
Definition: REveBoxSet.cxx:220
void AddBox(const Float_t *verts)
Create a new box from a set of 8 vertices.
Definition: REveBoxSet.cxx:116
Int_t WriteCoreJson(nlohmann::json &j, Int_t rnr_offset) override
Fill core part of JSON representation.
Definition: REveBoxSet.cxx:336
void BuildRenderData() override
Creates 3D point array for rendering.
Definition: REveBoxSet.cxx:347
void Test(Int_t nboxes)
Fill the structure with a random set of boxes.
Definition: REveBoxSet.cxx:406
void AddCone(const REveVector &pos, const REveVector &dir, Float_t r)
Create a cone with apex at pos, axis dir and radius r.
Definition: REveBoxSet.cxx:164
void Reset()
Reset the data containers to zero size.
Definition: REveBoxSet.cxx:106
void AddHex(const REveVector &pos, Float_t r, Float_t angle, Float_t depth)
Create a hexagonal prism with center of one hexagon at pos, radius of hexagon vertices r,...
Definition: REveBoxSet.cxx:202
void WriteShapeData(REveDigitSet::DigitBase_t &digit)
Write shape data for different cases.
Definition: REveBoxSet.cxx:377
static Int_t SizeofAtom(EBoxType_e bt)
Return size of data-structure describing a box of type bt.
Definition: REveBoxSet.cxx:72
void Reset(Int_t atom_size, Int_t chunk_size)
Empty the container and reset it with given atom and chunk sizes.
Int_t WriteCoreJson(nlohmann::json &j, Int_t rnr_offset) override
Fill core part of JSON representation.
DigitBase_t * NewDigit()
Function providing highlight tooltips when always-sec-select is active.
bool IsDigitVisible(const DigitBase_t *) const
Utility function for maping digit idx with visible shape idx.
void ReleaseIds()
Protected method.
void DigitValue(Int_t value)
Set signal value for the last digit added.
std::unique_ptr< REveRenderData > fRenderData
Externally assigned and controlled user data.
REveException Exception-type thrown by Eve classes.
Definition: REveTypes.hxx:41
const UChar_t * ColorFromValue(Int_t val) const
static void CheckAndFixBoxOrientationFv(Float_t box[8][3])
Make sure box orientation is consistent with standard arrangement.
Definition: REveShape.cxx:268
static void ColorFromIdx(Color_t ci, UChar_t col[4], Bool_t alpha=kTRUE)
Fill col with RGBA values corresponding to index ci.
Definition: REveUtil.cxx:118
void BBoxCheckPoint(Float_t x, Float_t y, Float_t z)
Definition: TAttBBox.h:58
void BBoxZero(Float_t epsilon=0, Float_t x=0, Float_t y=0, Float_t z=0)
Create cube of volume (2*epsilon)^3 at (x,y,z).
Definition: TAttBBox.cxx:42
void BBoxInit(Float_t infinity=1e6)
Dynamic Float_t[6] X(min,max), Y(min,max), Z(min,max)
Definition: TAttBBox.cxx:29
Float_t * fBBox
Definition: TAttBBox.h:20
SCoord_t fY
Definition: TPoint.h:36
SCoord_t fX
Definition: TPoint.h:35
This is the base class for the ROOT Random number generators.
Definition: TRandom.h:27
virtual Double_t Uniform(Double_t x1=1)
Returns a uniform deviate on the interval (0, x1).
Definition: TRandom.cxx:672
virtual UInt_t Integer(UInt_t imax)
Returns a random integer uniformly distributed on the interval [ 0, imax-1 ].
Definition: TRandom.cxx:360
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition: fillpatterns.C:1
const Int_t n
Definition: legend1.C:16
Short_t Max(Short_t a, Short_t b)
Returns the largest of a and b.
Definition: TMathBase.h:250
Double_t Sqrt(Double_t x)
Returns the square root of x.
Definition: TMath.h:660
basic_json< std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, double, std::allocator, adl_serializer, std::vector< std::uint8_t > > json
Definition: REveElement.hxx:36
TArc a
Definition: textangle.C:12