Logo ROOT  
Reference Guide
REvePointSet.cxx
Go to the documentation of this file.
1 // @(#)root/eve7:$Id$
2 // Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2019, 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/REvePointSet.hxx>
13 
14 #include <ROOT/REveManager.hxx>
16 #include <ROOT/REveTrans.hxx>
17 #include <ROOT/REveRenderData.hxx>
18 
19 #include "TArrayI.h"
20 #include "TClass.h"
21 
22 #include "json.hpp"
23 
24 
25 using namespace ROOT::Experimental;
26 namespace REX = ROOT::Experimental;
27 
28 /** \class REvePointSet
29 \ingroup REve
30 REvePointSet is a render-element holding a collection of 3D points with
31 optional per-point TRef and an arbitrary number of integer ids (to
32 be used for signal, volume-id, track-id, etc).
33 
34 3D point representation is implemented in base-class TPolyMarker3D.
35 Per-point TRef is implemented in base-class TPointSet3D.
36 
37 By using the REvePointSelector the points and integer ids can be
38 filled directly from a TTree holding the source data.
39 Setting of per-point TRef's is not supported.
40 
41 REvePointSet is a REveProjectable: it can be projected by using the
42 REveProjectionManager class.
43 */
44 
45 ////////////////////////////////////////////////////////////////////////////////
46 /// Constructor.
47 
48 REvePointSet::REvePointSet(const std::string& name, const std::string& title, Int_t n_points) :
49  REveElement(name, title),
50  TAttMarker(),
51  TAttBBox()
52 {
53  fMarkerStyle = 20;
54 
56 
57  Reset(n_points);
58 
59  // Override from REveElement.
60  fPickable = kTRUE;
61 }
62 
63 ////////////////////////////////////////////////////////////////////////////////
64 /// Copy constructor.
65 
67  REveElement(e),
69  TAttMarker(e),
70  TAttBBox(e)
71 {
72 }
73 
74 ////////////////////////////////////////////////////////////////////////////////
75 /// Destructor.
76 
78 {
79 }
80 
81 ////////////////////////////////////////////////////////////////////////////////
82 /// Clone points and all point-related information from point-set 'e'.
83 
85 {
86  fPoints = e.fPoints;
87  fCapacity = e.fCapacity;
88  fSize = e.fSize;
89 }
90 
91 ////////////////////////////////////////////////////////////////////////////////
92 /// Drop all data and set-up the data structures to recive new data.
93 /// n_points specifies the initial size of the array.
94 
95 void REvePointSet::Reset(Int_t n_points)
96 {
97  fPoints.resize(n_points);
98  fCapacity = n_points;
99  fSize = 0;
100 
101  ResetBBox();
102 }
103 
104 ////////////////////////////////////////////////////////////////////////////////
105 /// Resizes internal array to allow additional n_points to be stored.
106 /// Returns the old size which is also the location where one can
107 /// start storing new data.
108 /// The caller is *obliged* to fill the new point slots.
109 
111 {
112  assert(n_points >= 0);
113 
114  Int_t old_size = fCapacity;
115  Int_t new_size = old_size + n_points;
116 
117  fPoints.resize(new_size);
118  fCapacity = new_size;
119 
120  return old_size;
121 }
122 
123 int REvePointSet::SetNextPoint(float x, float y, float z)
124 {
125  return SetPoint(fSize, x, y, z);
126 }
127 
128 int REvePointSet::SetPoint(int n, float x, float y, float z)
129 {
130  if (n >= fCapacity)
131  {
132  fCapacity = std::max(n + 1, 2*fCapacity);
133  fPoints.resize(fCapacity);
134  }
135  fPoints[n].Set(x, y, z);
136  if (n >= fSize)
137  {
138  fSize = n + 1;
139  }
140  return fSize;
141 }
142 
143 ////////////////////////////////////////////////////////////////////////////////
144 /// Set marker style, propagate to projecteds.
145 
147 {
148  for (auto &pi: fProjectedList)
149  {
150  REvePointSet* pt = dynamic_cast<REvePointSet *>(pi);
151  if (pt)
152  {
153  pt->SetMarkerStyle(mstyle);
154  pt->StampObjProps();
155  }
156  }
158 }
159 
160 ////////////////////////////////////////////////////////////////////////////////
161 /// Set marker size, propagate to projecteds.
162 
164 {
165  for (auto &pi: fProjectedList)
166  {
167  REvePointSet* pt = dynamic_cast<REvePointSet *>(pi);
168  if (pt)
169  {
170  pt->SetMarkerSize(msize);
171  pt->StampObjProps();
172  }
173  }
175  StampObjProps();
176 }
177 
178 ////////////////////////////////////////////////////////////////////////////////
179 /// Copy visualization parameters from element el.
180 
182 {
183  const REvePointSet* m = dynamic_cast<const REvePointSet*>(el);
184  if (m)
185  {
187  }
188 
190 }
191 
192 ////////////////////////////////////////////////////////////////////////////////
193 /// Write visualization parameters.
194 
195 void REvePointSet::WriteVizParams(std::ostream& out, const TString& var)
196 {
197  REveElement::WriteVizParams(out, var);
198 
200 }
201 
202 ////////////////////////////////////////////////////////////////////////////////
203 /// Virtual from REveProjectable, returns REvePointSetProjected class.
204 
206 {
207  return TClass::GetClass<REvePointSetProjected>();
208 }
209 
210 
212 {
213  Int_t ret = REveElement::WriteCoreJson(j, rnr_offset);
214 
215  j["fMarkerSize"] = GetMarkerSize();
216  j["fMarkerColor"] = GetMarkerColor();
217 
218  return ret;
219 }
220 
221 ////////////////////////////////////////////////////////////////////////////////
222 /// Crates 3D point array for rendering.
223 
225 {
226  if (fSize > 0)
227  {
228  fRenderData = std::make_unique<REveRenderData>("makeHit", 3*fSize);
229  fRenderData->PushV(&fPoints[0].fX, 3*fSize);
230  }
231 }
232 
233 ////////////////////////////////////////////////////////////////////////////////
234 /// Compute bounding box.
235 
237 {
238  if (fSize > 0) {
239  BBoxInit();
240  for (auto &p : fPoints)
241  {
242  BBoxCheckPoint(p.fX, p.fY, p.fZ);
243  }
244  } else {
245  BBoxZero();
246  }
247 }
248 
249 ////////////////////////////////////////////////////////////////////////////////
250 /// Virtual method of base class TPointSet3D. The function call is
251 /// invoked with secondary selection in TPointSet3DGL.
252 
254 {
255  // Emit("PointSelected(Int_t)", id);
256 }
257 
258 
259 //==============================================================================
260 // REvePointSetArray
261 //==============================================================================
262 
263 /** \class REvePointSetArray
264 \ingroup REve
265 An array of point-sets with each point-set playing a role of a bin
266 in a histogram. When a new point is added to a REvePointSetArray,
267 an additional separating quantity needs to be specified: it
268 determines into which REvePointSet (bin) the point will actually be
269 stored. Underflow and overflow bins are automatically created but
270 they are not drawn by default.
271 
272 By using the REvePointSelector the points and the separating
273 quantities can be filled directly from a TTree holding the source
274 data.
275 Setting of per-point TRef's is not supported.
276 
277 After the filling, the range of separating variable can be
278 controlled with a slider to choose a sub-set of PointSets that are
279 actually shown.
280 */
281 
282 ////////////////////////////////////////////////////////////////////////////////
283 /// Constructor.
284 
286  const std::string& title) :
287  REveElement(name, title),
288 
289  fBins(nullptr), fDefPointSetCapacity(128), fNBins(0), fLastBin(-1),
290  fMin(0), fCurMin(0), fMax(0), fCurMax(0),
291  fBinWidth(0),
292  fQuantName()
293 {
295 }
296 
297 ////////////////////////////////////////////////////////////////////////////////
298 /// Destructor: deletes the fBins array. Actual removal of
299 /// elements done by REveElement.
300 
302 {
303  // printf("REvePointSetArray::~REvePointSetArray()\n");
304  delete [] fBins; fBins = nullptr;
305 }
306 
307 ////////////////////////////////////////////////////////////////////////////////
308 /// Virtual from REveElement, provide bin management.
309 
311 {
312  for (Int_t i=0; i<fNBins; ++i) {
313  if (fBins[i] == el) {
314  fBins[i] = nullptr;
315  break;
316  }
317  }
318 }
319 
320 ////////////////////////////////////////////////////////////////////////////////
321 /// Virtual from REveElement, provide bin management.
322 
324 {
325  delete [] fBins; fBins = nullptr; fLastBin = -1;
326 }
327 
328 ////////////////////////////////////////////////////////////////////////////////
329 /// Set marker color, propagate to children.
330 
332 {
333  for (auto & el : fChildren)
334  {
335  TAttMarker* m = dynamic_cast<TAttMarker*>(el);
336  if (m && m->GetMarkerColor() == fMarkerColor)
337  m->SetMarkerColor(tcolor);
338  }
340 }
341 
342 ////////////////////////////////////////////////////////////////////////////////
343 /// Set marker style, propagate to children.
344 
346 {
347  for (auto & el : fChildren)
348  {
349  TAttMarker* m = dynamic_cast<TAttMarker*>(el);
350  if (m && m->GetMarkerStyle() == fMarkerStyle)
351  m->SetMarkerStyle(mstyle);
352  }
354 }
355 
356 ////////////////////////////////////////////////////////////////////////////////
357 /// Set marker size, propagate to children.
358 
360 {
361  for (auto & el : fChildren)
362  {
363  TAttMarker* m = dynamic_cast<TAttMarker*>(el);
364  if (m && m->GetMarkerSize() == fMarkerSize)
365  m->SetMarkerSize(msize);
366  }
368 }
369 
370 ////////////////////////////////////////////////////////////////////////////////
371 /// Get the total number of filled points.
372 /// 'under' and 'over' flags specify if under/overflow channels
373 /// should be added to the sum.
374 
376 {
377  Int_t size = 0;
378  const Int_t min = under ? 0 : 1;
379  const Int_t max = over ? fNBins : fNBins - 1;
380  for (Int_t i = min; i < max; ++i)
381  {
382  if (fBins[i])
383  size += fBins[i]->GetSize();
384  }
385  return size;
386 }
387 
388 ////////////////////////////////////////////////////////////////////////////////
389 /// Initialize internal point-sets with given binning parameters.
390 /// The actual number of bins is nbins+2, bin 0 corresponding to
391 /// underflow and bin nbin+1 to owerflow pointset.
392 
393 void REvePointSetArray::InitBins(const std::string& quant_name,
394  Int_t nbins, Double_t min, Double_t max)
395 {
396  static const REveException eh("REvePointSetArray::InitBins ");
397 
398  if (nbins < 1) throw eh + "nbins < 1.";
399  if (min > max) throw eh + "min > max.";
400 
401  RemoveElements();
402 
403  fQuantName = quant_name;
404  fNBins = nbins + 2; // under/overflow
405  fLastBin = -1;
406  fMin = fCurMin = min;
407  fMax = fCurMax = max;
408  fBinWidth = (fMax - fMin)/(fNBins - 2);
409 
410  fBins = new REvePointSet* [fNBins];
411 
412  for (Int_t i = 0; i < fNBins; ++i)
413  {
414  fBins[i] = new REvePointSet
415  (Form("Slice %d [%4.3lf, %4.3lf]", i, fMin + (i-1)*fBinWidth, fMin + i*fBinWidth),
416  "",
421  AddElement(fBins[i]);
422  }
423 
424  fBins[0]->SetName("Underflow");
425  fBins[0]->SetRnrSelf(kFALSE);
426 
427  fBins[fNBins-1]->SetName("Overflow");
429 }
430 
431 ////////////////////////////////////////////////////////////////////////////////
432 /// Add a new point. Appropriate point-set will be chosen based on
433 /// the value of the separating quantity 'quant'.
434 /// If the selected bin does not have an associated REvePointSet
435 /// the point is discarded and false is returned.
436 
438 {
439  fLastBin = TMath::FloorNint((quant - fMin)/fBinWidth) + 1;
440 
441  if (fLastBin < 0)
442  {
443  fLastBin = 0;
444  }
445  else if (fLastBin > fNBins - 1)
446  {
447  fLastBin = fNBins - 1;
448  }
449 
450  if (fBins[fLastBin] != 0)
451  {
452  fBins[fLastBin]->SetNextPoint(x, y, z);
453  return kTRUE;
454  }
455  else
456  {
457  return kFALSE;
458  }
459 }
460 
461 ////////////////////////////////////////////////////////////////////////////////
462 /// Call this after all the points have been filled.
463 /// At this point we can calculate bounding-boxes of individual
464 /// point-sets.
465 
467 {
468  for (Int_t i=0; i<fNBins; ++i)
469  {
470  if (fBins[i])
471  {
472  fBins[i]->SetTitle(Form("N=%d", fBins[i]->GetSize()));
473  fBins[i]->ComputeBBox();
474  }
475  }
476  fLastBin = -1;
477 }
478 
479 ////////////////////////////////////////////////////////////////////////////////
480 /// Set active range of the separating quantity.
481 /// Appropriate point-sets are tagged for rendering.
482 /// Over/underflow point-sets are left as they were.
483 
485 {
486  using namespace TMath;
487 
488  fCurMin = min; fCurMax = max;
489  Int_t low_b = Max(0, FloorNint((min-fMin)/fBinWidth)) + 1;
490  Int_t high_b = Min(fNBins-2, CeilNint ((max-fMin)/fBinWidth));
491 
492  for (Int_t i = 1; i < fNBins - 1; ++i)
493  {
494  if (fBins[i])
495  fBins[i]->SetRnrSelf(i>=low_b && i<=high_b);
496  }
497 }
498 
499 /** \class REvePointSetProjected
500 \ingroup REve
501 Projected copy of a REvePointSet.
502 */
503 
504 ////////////////////////////////////////////////////////////////////////////////
505 /// Default contructor.
506 
508  REvePointSet (),
509  REveProjected ()
510 {
511 }
512 
513 ////////////////////////////////////////////////////////////////////////////////
514 /// Set projection manager and projection model.
515 /// Virtual from REveProjected.
516 
519 {
521  CopyVizParams(dynamic_cast<REveElement*>(model));
522 }
523 
524 ////////////////////////////////////////////////////////////////////////////////
525 /// Set depth (z-coordinate) of the projected points.
526 
528 {
529  SetDepthCommon(d, this, fBBox);
530 
531  // XXXX rewrite
532 
533  Int_t n = fSize;
534  Float_t *p = & fPoints[0].fZ;
535  for (Int_t i = 0; i < n; ++i, p+=3)
536  *p = fDepth;
537 }
538 
539 ////////////////////////////////////////////////////////////////////////////////
540 /// Re-apply the projection.
541 /// Virtual from REveProjected.
542 
544 {
546  REvePointSet &ps = * dynamic_cast<REvePointSet*>(fProjectable);
547  REveTrans *tr = ps.PtrMainTrans(kFALSE);
548 
549  // XXXX rewrite
550 
551  Int_t n = ps.GetSize();
552  Reset(n);
553  fSize = n;
554  const Float_t *o = & ps.RefPoint(0).fX;
555  Float_t *p = & fPoints[0].fX;
556  for (Int_t i = 0; i < n; ++i, o+=3, p+=3)
557  {
558  proj.ProjectPointfv(tr, o, p, fDepth);
559  }
560 }
561 
562 ////////////////////////////////////////////////////////////////////////////////
563 /// Virtual method of base class TPointSet3D.
564 /// Forward to projectable.
565 
567 {
568  REvePointSet *ps = dynamic_cast<REvePointSet*>(fProjectable);
569  ps->PointSelected(id);
570 }
m
auto * m
Definition: textangle.C:8
ROOT::Experimental::REveProjected
Definition: REveProjectionBases.hxx:81
SetMarkerStyle
m SetMarkerStyle(20)
n
const Int_t n
Definition: legend1.C:16
ROOT::Experimental::REvePointSetArray::fMin
Double_t fMin
Index of the last filled REvePointSet.
Definition: REvePointSet.hxx:117
ROOT::Experimental::REvePointSetArray::fCurMax
Double_t fCurMax
Definition: REvePointSet.hxx:118
ROOT::Experimental::REvePointSetArray::fLastBin
Int_t fLastBin
Definition: REvePointSet.hxx:116
ROOT::Experimental::REvePointSetArray::SetRange
void SetRange(Double_t min, Double_t max)
Set active range of the separating quantity.
Definition: REvePointSet.cxx:484
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
e
#define e(i)
Definition: RSha256.hxx:121
Style_t
short Style_t
Definition: RtypesCore.h:80
SetMarkerColor
m SetMarkerColor(kBlue)
ROOT::Experimental::REveProjected::SetDepthCommon
void SetDepthCommon(Float_t d, REveElement *el, Float_t *bbox)
Utility function to update the z-values of the bounding-box.
Definition: REveProjectionBases.cxx:231
ROOT::Experimental::REveElement::fChildren
List_t fChildren
Definition: REveElement.hxx:111
ROOT::Experimental::REvePointSet::REvePointSet
REvePointSet(const std::string &name="", const std::string &title="", Int_t n_points=0)
Constructor.
Definition: REvePointSet.cxx:48
ROOT::Experimental::REvePointSet::Reset
void Reset(Int_t n_points=0)
Drop all data and set-up the data structures to recive new data.
Definition: REvePointSet.cxx:95
ROOT::Experimental::REveElement::RemoveElements
virtual void RemoveElements()
Remove all elements.
Definition: REveElement.cxx:939
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
nlohmann::json
basic_json<> json
Definition: REveElement.hxx:58
ROOT::Experimental::REvePointSet::SetNextPoint
int SetNextPoint(float x, float y, float z)
Definition: REvePointSet.cxx:123
ROOT::Experimental::REveElement::SetRnrSelf
virtual Bool_t SetRnrSelf(Bool_t rnr)
Set render state of this element, i.e.
Definition: REveElement.cxx:566
Form
char * Form(const char *fmt,...)
ROOT::Experimental::REveProjected::fDepth
Float_t fDepth
Definition: REveProjectionBases.hxx:89
ROOT::Experimental::REvePointSetArray::fCurMin
Double_t fCurMin
Definition: REvePointSet.hxx:117
REveTrans.hxx
ROOT::Experimental::REvePointSet::GetSize
int GetSize() const
Definition: REvePointSet.hxx:83
ROOT::Experimental::REvePointSetArray::fQuantName
std::string fQuantName
Definition: REvePointSet.hxx:120
ROOT::Experimental::REvePointSet::fCapacity
int fCapacity
Definition: REvePointSet.hxx:64
ROOT::Experimental::REvePointSet::BuildRenderData
void BuildRenderData() override
Crates 3D point array for rendering.
Definition: REvePointSet.cxx:224
TMath::CeilNint
Int_t CeilNint(Double_t x)
Definition: TMath.h:701
operator=
Binding & operator=(OUT(*fun)(void))
Definition: TRInterface_Binding.h:11
ROOT::Experimental::REveProjected::SetProjection
virtual void SetProjection(REveProjectionManager *mng, REveProjectable *model)
Sets projection manager and reference in the projectable object.
Definition: REveProjectionBases.cxx:191
ROOT::Experimental::REvePointSet::SetPoint
int SetPoint(int n, float x, float y, float z)
Definition: REvePointSet.cxx:128
TAttBBox::BBoxZero
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
TGeant4Unit::ps
static constexpr double ps
Definition: TGeant4SystemOfUnits.h:171
ROOT::Experimental::REvePointSetArray::fBins
REvePointSet ** fBins
Definition: REvePointSet.hxx:113
x
Double_t x[n]
Definition: legend1.C:17
ROOT::Experimental::REvePointSetArray::SetMarkerSize
void SetMarkerSize(Size_t msize=1) override
Set marker size, propagate to children.
Definition: REvePointSet.cxx:359
TClass.h
REvePointSet.hxx
ROOT::Experimental::REveTrans
Definition: REveTrans.hxx:29
ROOT::Experimental::REvePointSetProjected::SetProjection
void SetProjection(REveProjectionManager *proj, REveProjectable *model) override
Set projection manager and projection model.
Definition: REvePointSet.cxx:517
TString
Definition: TString.h:136
ROOT::Experimental::REvePointSet::SetMarkerStyle
void SetMarkerStyle(Style_t mstyle=1) override
Set marker style, propagate to projecteds.
Definition: REvePointSet.cxx:146
ROOT::Experimental::REveElement
Definition: REveElement.hxx:79
ROOT::Experimental::REvePointSet::CopyVizParams
void CopyVizParams(const REveElement *el) override
Copy visualization parameters from element el.
Definition: REvePointSet.cxx:181
ROOT::Experimental::REvePointSetArray::InitBins
void InitBins(const std::string &quant_name, Int_t nbins, Double_t min, Double_t max)
Initialize internal point-sets with given binning parameters.
Definition: REvePointSet.cxx:393
Color_t
short Color_t
Definition: RtypesCore.h:83
ROOT::Experimental::REveElement::SetTitle
void SetTitle(const std::string &title)
Set title of an element.
Definition: REveElement.cxx:220
ROOT::Experimental::REvePointSet::PointSelected
void PointSelected(Int_t id)
Virtual method of base class TPointSet3D.
Definition: REvePointSet.cxx:253
ROOT::Experimental::REvePointSetArray::fDefPointSetCapacity
Int_t fDefPointSetCapacity
Definition: REvePointSet.hxx:114
TAttBBox::fBBox
Float_t * fBBox
Definition: TAttBBox.h:26
ROOT::Experimental::REvePointSet::SetMarkerColor
void SetMarkerColor(Color_t col) override
Definition: REvePointSet.hxx:88
bool
ROOT::Experimental::REvePointSet::ComputeBBox
void ComputeBBox() override
Compute bounding box.
Definition: REvePointSet.cxx:236
ROOT::Experimental::REveProjection
REveProjection Base for specific classes that implement non-linear projections.
Definition: REveProjections.hxx:42
ROOT::Experimental::REvePointSetArray::SetMarkerColor
void SetMarkerColor(Color_t tcolor=1) override
Set marker color, propagate to children.
Definition: REvePointSet.cxx:331
TAttBBox
Definition: TAttBBox.h:17
TAttBBox::BBoxCheckPoint
void BBoxCheckPoint(Float_t x, Float_t y, Float_t z)
Definition: TAttBBox.h:58
REveRenderData.hxx
ROOT::Experimental::REvePointSet::fSize
int fSize
Definition: REvePointSet.hxx:65
ROOT::Experimental::REveElement::WriteCoreJson
virtual Int_t WriteCoreJson(nlohmann::json &cj, Int_t rnr_offset)
Write core json.
Definition: REveElement.cxx:1460
TMath::FloorNint
Int_t FloorNint(Double_t x)
Definition: TMath.h:709
ROOT::Experimental::REvePointSetArray::CloseBins
void CloseBins()
Call this after all the points have been filled.
Definition: REvePointSet.cxx:466
ROOT::Experimental::REvePointSet::~REvePointSet
virtual ~REvePointSet()
Destructor.
Definition: REvePointSet.cxx:77
TAttMarker::SaveMarkerAttributes
virtual void SaveMarkerAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t sizdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition: TAttMarker.cxx:339
ROOT::Experimental::REvePointSet::WriteCoreJson
Int_t WriteCoreJson(nlohmann::json &j, Int_t rnr_offset) override
Write core json.
Definition: REvePointSet.cxx:211
ROOT::Experimental::REveProjectable::fProjectedList
ProjList_t fProjectedList
Definition: REveProjectionBases.hxx:46
ROOT::Experimental::REvePointSetArray::Size
Int_t Size(Bool_t under=kFALSE, Bool_t over=kFALSE) const
Get the total number of filled points.
Definition: REvePointSet.cxx:375
ROOT::Experimental::REvePointSetProjected::UpdateProjection
void UpdateProjection() override
Re-apply the projection.
Definition: REvePointSet.cxx:543
ROOT::Experimental::REvePointSetArray::REvePointSetArray
REvePointSetArray(const REvePointSetArray &)=delete
ROOT::Experimental::REveElement::fRenderData
std::unique_ptr< REveRenderData > fRenderData
Externally assigned and controlled user data.
Definition: REveElement.hxx:133
ROOT::Experimental::REveElement::CopyVizParams
virtual void CopyVizParams(const REveElement *el)
Copy visualization parameters from element el.
Definition: REveElement.cxx:352
SetMarkerSize
gr SetMarkerSize(1.3)
ROOT::Experimental::REveException
REveException Exception-type thrown by Eve classes.
Definition: REveTypes.hxx:40
ROOT::Experimental::REvePointSetProjected::PointSelected
void PointSelected(Int_t id)
Virtual method of base class TPointSet3D.
Definition: REvePointSet.cxx:566
TAttBBox::ResetBBox
void ResetBBox()
Definition: TAttBBox.h:52
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
ROOT::Experimental::REveProjectable
Definition: REveProjectionBases.hxx:37
TAttMarker
Definition: TAttMarker.h:19
ROOT::Experimental::REvePointSet::WriteVizParams
void WriteVizParams(std::ostream &out, const TString &var) override
Write visualization parameters.
Definition: REvePointSet.cxx:195
TArrayI.h
TAttBBox::BBoxInit
void BBoxInit(Float_t infinity=1e6)
Dynamic Float_t[6] X(min,max), Y(min,max), Z(min,max)
Definition: TAttBBox.cxx:29
ROOT::Experimental::REvePointSet
Definition: REvePointSet.hxx:46
y
Double_t y[n]
Definition: legend1.C:17
ROOT::Experimental::REvePointSet::ClonePoints
virtual void ClonePoints(const REvePointSet &e)
Clone points and all point-related information from point-set 'e'.
Definition: REvePointSet.cxx:84
ROOT::Experimental::REvePointSetArray::fNBins
Int_t fNBins
Definition: REvePointSet.hxx:115
TMath::Min
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180
REveProjectionManager.hxx
ROOT::Experimental::REvePointSet::fPoints
std::vector< REveVector > fPoints
Definition: REvePointSet.hxx:63
ROOT::Experimental::REvePointSet::GrowFor
Int_t GrowFor(Int_t n_points)
Resizes internal array to allow additional n_points to be stored.
Definition: REvePointSet.cxx:110
ROOT::Experimental::REvePointSetArray::fBinWidth
Double_t fBinWidth
Definition: REvePointSet.hxx:119
ROOT::Experimental::REvePointSetProjected::REvePointSetProjected
REvePointSetProjected()
Default contructor.
Definition: REvePointSet.cxx:507
ROOT::Experimental::REveElement::fPickable
Bool_t fPickable
Definition: REveElement.hxx:324
REveManager.hxx
ROOT::Experimental::REveElement::StampObjProps
void StampObjProps()
Definition: REveElement.hxx:378
ROOT::Experimental::REveElement::SetName
void SetName(const std::string &name)
Set name of an element.
Definition: REveElement.cxx:211
Double_t
double Double_t
Definition: RtypesCore.h:59
ROOT::Experimental::REveElement::AddElement
virtual void AddElement(REveElement *el)
Add el to the list of children.
Definition: REveElement.cxx:842
ROOT::Experimental::REveElement::SetMainColorPtr
void SetMainColorPtr(Color_t *colptr)
Definition: REveElement.hxx:265
ROOT::Experimental::REvePointSetArray::fMax
Double_t fMax
Definition: REvePointSet.hxx:118
TGeant4Unit::pi
static constexpr double pi
Definition: TGeant4SystemOfUnits.h:73
ROOT::Experimental::REvePointSet::SetMarkerSize
void SetMarkerSize(Size_t msize=1) override
Set marker size, propagate to projecteds.
Definition: REvePointSet.cxx:163
TClass
Definition: TClass.h:80
TAttMarker::fMarkerColor
Color_t fMarkerColor
Marker color.
Definition: TAttMarker.h:28
name
char name[80]
Definition: TGX11.cxx:110
ROOT::Experimental::REvePointSetArray::RemoveElementLocal
void RemoveElementLocal(REveElement *el) override
Virtual from REveElement, provide bin management.
Definition: REvePointSet.cxx:310
ROOT::Experimental::REveProjected::fManager
REveProjectionManager * fManager
Definition: REveProjectionBases.hxx:87
TAttMarker::fMarkerStyle
Style_t fMarkerStyle
Marker style.
Definition: TAttMarker.h:29
d
#define d(i)
Definition: RSha256.hxx:120
ROOT::Experimental::REveProjectionManager::GetProjection
REveProjection * GetProjection()
Definition: REveProjectionManager.hxx:75
make_cnn_model.model
model
Definition: make_cnn_model.py:6
ROOT::Experimental
Definition: RDirectory.hxx:36
Float_t
pt
TPaveText * pt
Definition: entrylist_figure1.C:7
ROOT::Experimental::REvePointSetArray::SetMarkerStyle
void SetMarkerStyle(Style_t mstyle=1) override
Set marker style, propagate to children.
Definition: REvePointSet.cxx:345
TAttMarker::fMarkerSize
Size_t fMarkerSize
Marker size.
Definition: TAttMarker.h:30
ROOT::Experimental::REveProjectionManager
REveProjectionManager Manager class for steering of projections and managing projected objects.
Definition: REveProjectionManager.hxx:39
ROOT::Experimental::REveElement::WriteVizParams
virtual void WriteVizParams(std::ostream &out, const TString &var)
Write-out visual parameters for this object.
Definition: REveElement.cxx:412
ROOT::Experimental::REvePointSet::ProjectedClass
TClass * ProjectedClass(const REveProjection *p) const override
Virtual from REveProjectable, returns REvePointSetProjected class.
Definition: REvePointSet.cxx:205
ROOT::Experimental::REvePointSetProjected::SetDepthLocal
void SetDepthLocal(Float_t d) override
Set depth (z-coordinate) of the projected points.
Definition: REvePointSet.cxx:527
ROOT::Experimental::REvePointSetArray::RemoveElementsLocal
void RemoveElementsLocal() override
Virtual from REveElement, provide bin management.
Definition: REvePointSet.cxx:323
TMath
TMath.
Definition: TMathBase.h:35
ROOT::Experimental::REveProjected::fProjectable
REveProjectable * fProjectable
Definition: REveProjectionBases.hxx:88
ROOT::Experimental::REveProjection::ProjectPointfv
void ProjectPointfv(Float_t *v, Float_t d)
Project float array.
Definition: REveProjections.cxx:56
ROOT::Experimental::REvePointSetArray::Fill
Bool_t Fill(Double_t x, Double_t y, Double_t z, Double_t quant)
Add a new point.
Definition: REvePointSet.cxx:437
int
Size_t
float Size_t
Definition: RtypesCore.h:87
ROOT::Experimental::REvePointSetArray::~REvePointSetArray
virtual ~REvePointSetArray()
Destructor: deletes the fBins array.
Definition: REvePointSet.cxx:301