LSSTApplications  20.0.0
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
lsst::afw::image::ImageSlice::COLUMN
@ COLUMN
Definition: ImageSlice.h:48
lsst::afw::image
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects.
Definition: imageAlgorithm.dox:1
std::shared_ptr
STL class.
lsst::ip::diffim::detail::PixelT
float PixelT
Definition: AssessSpatialKernelVisitor.cc:208
lsst::afw
Definition: imageAlgorithm.dox:1
ImageSlice.h
lsst::afw::image::operator*
std::shared_ptr< Image< PixelT > > operator*(Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
Overload operator*()
Definition: ImageSlice.cc:104
lsst::afw::image::ImageBase::getHeight
int getHeight() const
Return the number of rows in the image.
Definition: ImageBase.h:335
lsst::afw::image::ImageSlice
A class to specify a slice of an image.
Definition: ImageSlice.h:46
lsst::afw::image::operator*=
Image< LhsPixelT > & operator*=(Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
Multiply lhs by Image rhs (i.e. pixel-by-pixel multiplication) where types are different.
Definition: Image.cc:683
lsst::afw::image::operator-
std::shared_ptr< Image< PixelT > > operator-(Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
Overload operator-()
Definition: ImageSlice.cc:89
lsst::afw::image::ImageSlice::ImageSlice
ImageSlice(Image< PixelT > const &img)
Constructor for ImageSlice.
Definition: ImageSlice.cc:41
lsst::afw::image::operator/
std::shared_ptr< Image< PixelT > > operator/(Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
Overload operator/()
Definition: ImageSlice.cc:123
lsst::afw::image::operator-=
Image< LhsPixelT > & operator-=(Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
Subtract lhs from Image rhs (i.e. pixel-by-pixel subtraction) where types are different.
Definition: Image.cc:677
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
LSST_EXCEPT
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
lsst::pex::exceptions::InvalidParameterError
Reports invalid arguments.
Definition: Runtime.h:66
lsst::afw::image::ImageSlice::getImageSliceType
ImageSliceType getImageSliceType() const
Definition: ImageSlice.h:57
lsst::afw::image::operator+
std::shared_ptr< Image< PixelT > > operator+(Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
Overload operator+()
Definition: ImageSlice.cc:69
lsst::afw::image::operator/=
Image< LhsPixelT > & operator/=(Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
Divide lhs by Image rhs (i.e. pixel-by-pixel division) where types are different.
Definition: Image.cc:689
lsst::pex::exceptions::OutOfRangeError
Reports attempts to access elements outside a valid range of indices.
Definition: Runtime.h:89
lsst::pex::exceptions
Definition: Exception.h:37
lsst::afw::image::operator+=
Image< LhsPixelT > & operator+=(Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
Add lhs to Image rhs (i.e. pixel-by-pixel addition) where types are different.
Definition: Image.cc:671
lsst::afw::image::Image
A class to represent a 2-dimensional array of pixels.
Definition: Image.h:58
lsst::afw::image::ImageSlice::ROW
@ ROW
Definition: ImageSlice.h:48
exceptions.h
lsst::afw::image::ImageBase::getWidth
int getWidth() const
Return the number of columns in the image.
Definition: ImageBase.h:333