LSSTApplications  19.0.0+10,19.0.0+80,19.0.0-1-g20d9b18+31,19.0.0-1-g49a97f9+4,19.0.0-1-g8c57eb9+31,19.0.0-1-g9a028c0+13,19.0.0-1-ga72da6b+3,19.0.0-1-gb77924a+15,19.0.0-1-gbfe0924+66,19.0.0-1-gc3516c3,19.0.0-1-gefe1d0d+49,19.0.0-1-gf8cb8b4+3,19.0.0-14-g7511ce4+6,19.0.0-16-g3dc1a33c+6,19.0.0-17-g59f0e8a+4,19.0.0-17-g9c22e3c+9,19.0.0-18-g35bb99870+2,19.0.0-19-g2772d4a+9,19.0.0-2-g260436e+53,19.0.0-2-g31cdcee,19.0.0-2-g9675b69+3,19.0.0-2-gaa2795f,19.0.0-2-gbcc4de1,19.0.0-2-gd6f004e+6,19.0.0-2-gde8e5e3+5,19.0.0-2-gff6972b+15,19.0.0-21-ge306cd8,19.0.0-21-gf122e69+2,19.0.0-3-g2d43a51+2,19.0.0-3-gf3b1435+6,19.0.0-4-g56feb96,19.0.0-4-gac56cce+17,19.0.0-49-gce872c1+1,19.0.0-5-g66946eb+6,19.0.0-5-gd8897ba+6,19.0.0-51-gfc4a647e,19.0.0-7-g686a884+5,19.0.0-7-g886f805+5,19.0.0-8-g305ff64,w.2020.17
LSSTDataManagementBasePackage
ImageSlice.cc
Go to the documentation of this file.
1 // -*- lsst-c++ -*-
2 
3 /*
4  * LSST Data Management System
5  * Copyright 2008, 2009, 2010 LSST Corporation.
6  *
7  * This product includes software developed by the
8  * LSST Project (http://www.lsst.org/).
9  *
10  * This program is free software: you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation, either version 3 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the LSST License Statement and
21  * the GNU General Public License along with this program. If not,
22  * see <http://www.lsstcorp.org/LegalNotices/>.
23  */
24 
25 /*
26  * Provide functions to operate on rows/columns of images
27  */
28 #include <vector>
29 #include <memory>
30 
31 #include "lsst/pex/exceptions.h"
33 
34 namespace ex = lsst::pex::exceptions;
35 
36 namespace lsst {
37 namespace afw {
38 namespace image {
39 
40 template <typename PixelT>
41 ImageSlice<PixelT>::ImageSlice(image::Image<PixelT> const &img) : Image<PixelT>(img), _sliceType(ROW) {
42  // verify the img is a slice (row or column)
43  if (img.getWidth() != 1 && img.getHeight() != 1) {
44  throw LSST_EXCEPT(ex::OutOfRangeError, "Input image must be a slice (width or height == 1)");
45  } else if (img.getWidth() == 1 && img.getHeight() == 1) {
47  "1x1 image ambiguous (could be row or column). "
48  "Perhaps a constant would be better than a slice? ");
49  } else if (img.getWidth() == 1 && img.getHeight() != 1) {
50  _sliceType = COLUMN;
51  } else if (img.getHeight() == 1 && img.getWidth() != 1) {
52  _sliceType = ROW;
53  }
54 
55  // what about 1xn images where a 1x1 row slice is desired? ... use a constant instead of a slice
56  // what about nx1 images wehre a 1x1 column slice is desired? ... use a constant instead of a slice
57 }
58 
59 /* ************************************************************************ *
60  *
61  * column operators
62  *
63  * ************************************************************************ */
64 
65 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
66 // overload +
67 
68 template <typename PixelT>
70  std::shared_ptr<Image<PixelT>> retImg(new Image<PixelT>(img, true));
71  *retImg += slc;
72  return retImg;
73 }
74 
75 template <typename PixelT>
77  return operator+(img, slc);
78 }
79 
80 template <typename PixelT>
82  details::operate<details::Plus<PixelT>>(img, slc, slc.getImageSliceType());
83 }
84 
85 // -----------------------------------------------------------------
86 // overload -
87 
88 template <typename PixelT>
90  std::shared_ptr<Image<PixelT>> retImg(new Image<PixelT>(img, true));
91  *retImg -= slc;
92  return retImg;
93 }
94 
95 template <typename PixelT>
97  details::operate<details::Minus<PixelT>>(img, slc, slc.getImageSliceType());
98 }
99 
100 // ******************************************************************
101 // overload *
102 
103 template <typename PixelT>
105  std::shared_ptr<Image<PixelT>> retImg(new Image<PixelT>(img, true));
106  *retImg *= slc;
107  return retImg;
108 }
109 
110 template <typename PixelT>
112  return operator*(img, slc);
113 }
114 
115 template <typename PixelT>
117  details::operate<details::Mult<PixelT>>(img, slc, slc.getImageSliceType());
118 }
119 
120 // overload
121 
122 template <typename PixelT>
124  std::shared_ptr<Image<PixelT>> retImg(new Image<PixelT>(img, true));
125  *retImg /= slc;
126  return retImg;
127 }
128 
129 template <typename PixelT>
131  details::operate<details::Div<PixelT>>(img, slc, slc.getImageSliceType());
132 }
133 
134 /*
135  * Explicit Instantiations
136  *
137  */
139 #define INSTANTIATE_SLICE_OP_SYM(TYPE, OP) \
140  template std::shared_ptr<Image<TYPE>> operator OP(Image<TYPE> const &img, ImageSlice<TYPE> const &slc); \
141  template std::shared_ptr<Image<TYPE>> operator OP(ImageSlice<TYPE> const &slc, Image<TYPE> const &img)
142 
143 #define INSTANTIATE_SLICE_OP_ASYM(TYPE, OP) \
144  template std::shared_ptr<Image<TYPE>> operator OP(Image<TYPE> const &img, ImageSlice<TYPE> const &slc)
145 
146 #define INSTANTIATE_SLICE_OPEQ(TYPE, OP) \
147  template void operator OP(Image<TYPE> &img, ImageSlice<TYPE> const &slc)
148 
149 #define INSTANTIATE_SLICES(TYPE) \
150  template ImageSlice<TYPE>::ImageSlice(Image<TYPE> const &image); \
151  INSTANTIATE_SLICE_OP_SYM(TYPE, +); \
152  INSTANTIATE_SLICE_OP_ASYM(TYPE, -); \
153  INSTANTIATE_SLICE_OP_SYM(TYPE, *); \
154  INSTANTIATE_SLICE_OP_ASYM(TYPE, /); \
155  INSTANTIATE_SLICE_OPEQ(TYPE, +=); \
156  INSTANTIATE_SLICE_OPEQ(TYPE, -=); \
157  INSTANTIATE_SLICE_OPEQ(TYPE, *=); \
158  INSTANTIATE_SLICE_OPEQ(TYPE, /=)
159 
160 INSTANTIATE_SLICES(double);
161 INSTANTIATE_SLICES(float);
163 } // namespace image
164 } // namespace afw
165 } // namespace lsst
std::shared_ptr< Image< PixelT > > operator/(Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
Overload operator/()
Definition: ImageSlice.cc:123
Image & operator*=(PixelT const rhs)
Multiply lhs by scalar rhs.
Definition: Image.cc:558
ImageSliceType getImageSliceType() const
Definition: ImageSlice.h:57
ImageSlice(Image< PixelT > const &img)
Constructor for ImageSlice.
Definition: ImageSlice.cc:41
int getHeight() const
Return the number of rows in the image.
Definition: ImageBase.h:335
std::shared_ptr< Image< PixelT > > operator*(Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
Overload operator*()
Definition: ImageSlice.cc:104
Image & operator/=(PixelT const rhs)
Divide lhs by scalar rhs.
Definition: Image.cc:590
std::shared_ptr< Image< PixelT > > operator+(Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
Overload operator+()
Definition: ImageSlice.cc:69
Image & operator-=(PixelT const rhs)
Subtract scalar rhs from lhs.
Definition: Image.cc:513
A base class for image defects.
Image & operator+=(PixelT const rhs)
Add scalar rhs to lhs.
Definition: Image.cc:468
std::shared_ptr< Image< PixelT > > operator-(Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
Overload operator-()
Definition: ImageSlice.cc:89
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
Reports attempts to access elements outside a valid range of indices.
Definition: Runtime.h:89
int getWidth() const
Return the number of columns in the image.
Definition: ImageBase.h:333
Reports invalid arguments.
Definition: Runtime.h:66
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects...
A class to represent a 2-dimensional array of pixels.
Definition: Image.h:58
A class to specify a slice of an image.
Definition: ImageSlice.h:46