From 90bc2cc788cfbc0c9ca6dbfbcbc19e1763ac6a69 Mon Sep 17 00:00:00 2001
From: Andrew Bell <andrew.bell.ia@gmail.com>
Date: Tue, 1 May 2018 12:12:09 -0400
Subject: [PATCH] Paren-ify max/min for Windows so as not to bleed into
 people's code that uses ours.

---
 examples/writing-reader/MyReader.cpp      |  2 +-
 filters/DecimationFilter.cpp              |  4 +--
 filters/GreedyProjection.cpp              |  2 +-
 filters/HeadFilter.hpp                    |  2 +-
 filters/LOFFilter.cpp                     |  2 +-
 filters/LocateFilter.cpp                  |  2 +-
 filters/MongusFilter.cpp                  | 10 +++---
 filters/SMRFilter.cpp                     |  2 +-
 filters/TailFilter.hpp                    |  2 +-
 filters/private/DimRange.cpp              |  4 +--
 io/BpfHeader.cpp                          |  2 +-
 io/BpfReader.cpp                          |  2 +-
 io/BpfWriter.cpp                          |  4 +--
 io/GDALGrid.cpp                           | 36 +++++++++----------
 io/GDALReader.cpp                         |  2 +-
 io/HeaderVal.hpp                          |  4 +--
 io/LasHeader.cpp                          |  2 +-
 io/LasReader.cpp                          |  9 +++--
 io/LasWriter.cpp                          |  4 +--
 io/LasWriter.hpp                          |  2 +-
 io/OptechReader.cpp                       |  4 +--
 io/PlyWriter.cpp                          |  4 +--
 io/QfitReader.cpp                         |  2 +-
 io/TerrasolidReader.cpp                   |  2 +-
 pdal/EigenUtils.cpp                       |  6 ++--
 pdal/KDIndex.hpp                          |  8 ++---
 pdal/PDALUtils.cpp                        |  2 +-
 pdal/PointLayout.cpp                      |  4 +--
 pdal/QuadIndex.cpp                        | 22 ++++++------
 pdal/Reader.cpp                           |  2 +-
 pdal/compression/LazPerfCompression.cpp   |  4 +--
 pdal/compression/LzmaCompression.cpp      |  2 +-
 pdal/util/Utils.cpp                       |  4 +--
 plugins/delaunay/filters/Delaunay_psm.cpp |  6 ++--
 plugins/delaunay/filters/Delaunay_psm.h   | 16 ++++-----
 plugins/greyhound/io/bounds.cpp           | 28 +++++++--------
 plugins/greyhound/io/bounds.hpp           | 42 +++++++++++++----------
 plugins/greyhound/io/point.hpp            | 36 ++++++++++---------
 plugins/icebridge/io/Hdf5Handler.cpp      |  2 +-
 plugins/icebridge/io/IcebridgeReader.cpp  |  2 +-
 plugins/mbio/io/MbReader.cpp              |  2 +-
 plugins/mrsid/io/MrsidReader.cpp          |  2 +-
 plugins/oci/test/OCITest.cpp              |  2 +-
 plugins/pcl/pipeline/PCLPipeline.hpp      | 16 ++++-----
 plugins/rxp/io/RxpPointcloud.cpp          |  4 +--
 plugins/rxp/test/RxpReaderTest.cpp        |  2 +-
 plugins/sqlite/io/SQLiteReader.cpp        |  2 +-
 test/unit/DeflateTest.cpp                 |  2 +-
 test/unit/LazPerfTest.cpp                 |  3 +-
 test/unit/LzmaTest.cpp                    |  2 +-
 test/unit/ZstdTest.cpp                    |  2 +-
 test/unit/io/LasWriterTest.cpp            |  4 +--
 tools/lasdump/Lasdump.hpp                 |  2 +-
 tools/nitfwrap/NitfWrap.cpp               |  2 +-
 vendor/arbiter/arbiter.cpp                |  2 +-
 55 files changed, 176 insertions(+), 170 deletions(-)

diff --git a/examples/writing-reader/MyReader.cpp b/examples/writing-reader/MyReader.cpp
index 5896075999..a9b30403e5 100644
--- a/examples/writing-reader/MyReader.cpp
+++ b/examples/writing-reader/MyReader.cpp
@@ -62,7 +62,7 @@ namespace pdal
     m_stream.reset(new ILeStream(m_filename));
 
     size_t HEADERSIZE(1);
-    size_t skip_lines(std::max(HEADERSIZE, (size_t)m_index));
+    size_t skip_lines((std::max)(HEADERSIZE, (size_t)m_index));
     size_t line_no(1);
     for (std::string line; std::getline(*m_stream->stream(), line); line_no++)
     {
diff --git a/filters/DecimationFilter.cpp b/filters/DecimationFilter.cpp
index 4f707ea87a..cb8f391290 100644
--- a/filters/DecimationFilter.cpp
+++ b/filters/DecimationFilter.cpp
@@ -57,7 +57,7 @@ void DecimationFilter::addArgs(ProgramArgs& args)
     args.add("offset", "Index of first point to consider including in output",
         m_offset);
     args.add("limit", "Index of last point to consider including in output",
-        m_limit, std::numeric_limits<point_count_t>::max());
+        m_limit, (std::numeric_limits<point_count_t>::max)());
 }
 
 PointViewSet DecimationFilter::run(PointViewPtr inView)
@@ -84,7 +84,7 @@ bool DecimationFilter::processOne(PointRef& point)
 
 void DecimationFilter::decimate(PointView& input, PointView& output)
 {
-    PointId last_idx = std::min(m_limit, input.size());
+    PointId last_idx = (std::min)(m_limit, input.size());
     for (PointId idx = m_offset; idx < last_idx; idx += m_step)
         output.appendPoint(input, idx);
 }
diff --git a/filters/GreedyProjection.cpp b/filters/GreedyProjection.cpp
index 0ac04fb6b3..890d0b0b51 100644
--- a/filters/GreedyProjection.cpp
+++ b/filters/GreedyProjection.cpp
@@ -135,7 +135,7 @@ void GreedyProjection::filter(PointView& view)
     const double sqr_mu = mu_ * mu_;
     const double sqr_max_edge = search_radius_*search_radius_;
 
-    nnn_ = (int)std::min((point_count_t)nnn_, view.size());
+    nnn_ = (int)(std::min)((point_count_t)nnn_, view.size());
 
     // Variables to hold the results of nearest neighbor searches
     std::vector<PointId> nnIdx(nnn_);
diff --git a/filters/HeadFilter.hpp b/filters/HeadFilter.hpp
index 79ac537da6..b6fcc09298 100644
--- a/filters/HeadFilter.hpp
+++ b/filters/HeadFilter.hpp
@@ -66,7 +66,7 @@ class PDAL_DLL HeadFilter : public Filter
                 << ") exceeds number of available points.\n";
         PointViewSet viewSet;
         PointViewPtr outView = view->makeNew();
-        for (PointId i = 0; i < std::min(m_count, view->size()); ++i)
+        for (PointId i = 0; i < (std::min)(m_count, view->size()); ++i)
             outView->appendPoint(*view, i);
         viewSet.insert(outView);
         return viewSet;
diff --git a/filters/LOFFilter.cpp b/filters/LOFFilter.cpp
index 0dad6f805d..20259adcec 100644
--- a/filters/LOFFilter.cpp
+++ b/filters/LOFFilter.cpp
@@ -109,7 +109,7 @@ void LOFFilter::filter(PointView& view)
         for (PointId j = 0; j < indices.size(); ++j)
         {
             double k = view.getFieldAs<double>(m_kdist, indices[j]);
-            double reachdist = std::max(k, std::sqrt(sqr_dists[j]));
+            double reachdist = (std::max)(k, std::sqrt(sqr_dists[j]));
             M1 += (reachdist - M1) / ++n;
         }
         view.setField(m_lrd, i, 1.0 / M1);
diff --git a/filters/LocateFilter.cpp b/filters/LocateFilter.cpp
index 58de188d0a..322cbc2c12 100644
--- a/filters/LocateFilter.cpp
+++ b/filters/LocateFilter.cpp
@@ -76,7 +76,7 @@ PointViewSet LocateFilter::run(PointViewPtr inView)
         return viewSet;
 
     PointId minidx, maxidx;
-    double minval = std::numeric_limits<double>::max();
+    double minval = (std::numeric_limits<double>::max)();
     double maxval = std::numeric_limits<double>::lowest();
 
     for (PointId idx = 0; idx < inView->size(); idx++)
diff --git a/filters/MongusFilter.cpp b/filters/MongusFilter.cpp
index 2179713736..77701f7349 100644
--- a/filters/MongusFilter.cpp
+++ b/filters/MongusFilter.cpp
@@ -143,7 +143,7 @@ std::vector<PointId> MongusFilter::processGround(PointViewPtr view)
     cy.setConstant(std::numeric_limits<double>::quiet_NaN());
 
     MatrixXd cz(m_numRows, m_numCols);
-    cz.setConstant(std::numeric_limits<double>::max());
+    cz.setConstant((std::numeric_limits<double>::max)());
 
     // find initial set of Z minimums at native resolution
     for (point_count_t i = 0; i < np; ++i)
@@ -250,7 +250,7 @@ std::vector<PointId> MongusFilter::processGround(PointViewPtr view)
 
         double sum = 0.0;
         double maxcoeff = std::numeric_limits<double>::lowest();
-        double mincoeff = std::numeric_limits<double>::max();
+        double mincoeff = (std::numeric_limits<double>::max)();
         for (auto i = 0; i < R.size(); ++i)
         {
             if (std::isnan(R(i)))
@@ -322,7 +322,7 @@ std::vector<PointId> MongusFilter::processGround(PointViewPtr view)
 
         sum = 0.0;
         maxcoeff = std::numeric_limits<double>::lowest();
-        mincoeff = std::numeric_limits<double>::max();
+        mincoeff = (std::numeric_limits<double>::max)();
         for (auto i = 0; i < M.size(); ++i)
         {
             if (std::isnan(M(i)))
@@ -477,13 +477,13 @@ void MongusFilter::downsampleMin(Eigen::MatrixXd *cx, Eigen::MatrixXd *cy,
     dcy->setConstant(std::numeric_limits<double>::quiet_NaN());
 
     dcz->resize(nr, nc);
-    dcz->setConstant(std::numeric_limits<double>::max());
+    dcz->setConstant((std::numeric_limits<double>::max)());
 
     for (auto c = 0; c < cz->cols(); ++c)
     {
         for (auto r = 0; r < cz->rows(); ++r)
         {
-            if ((*cz)(r, c) == std::numeric_limits<double>::max())
+            if ((*cz)(r, c) == (std::numeric_limits<double>::max)())
                 continue;
 
             int rr = std::floor(r/cell_size);
diff --git a/filters/SMRFilter.cpp b/filters/SMRFilter.cpp
index 8c68a66f19..3a0103ed13 100644
--- a/filters/SMRFilter.cpp
+++ b/filters/SMRFilter.cpp
@@ -577,7 +577,7 @@ std::vector<int> SMRFilter::progressiveFilter(std::vector<double> const& ZImin,
                            return (x > threshold) ? int(1) : int(0);
                        });
         std::transform(Obj.begin(), Obj.end(), foo.begin(), Obj.begin(),
-                       [](int a, int b) { return std::max(a, b); });
+                       [](int a, int b) { return (std::max)(a, b); });
 
         // "The algorithm then proceeds to the next window radius (up to the
         // maximum), and proceeds as above with the last opened surface acting
diff --git a/filters/TailFilter.hpp b/filters/TailFilter.hpp
index 7527f3fe5c..d7786765e6 100644
--- a/filters/TailFilter.hpp
+++ b/filters/TailFilter.hpp
@@ -66,7 +66,7 @@ class PDAL_DLL TailFilter : public Filter
                 << ") exceeds number of available points.\n";
         PointViewSet viewSet;
         PointViewPtr outView = view->makeNew();
-        for (PointId i = view->size() - std::min(m_count, view->size());
+        for (PointId i = view->size() - (std::min)(m_count, view->size());
              i < view->size(); ++i)
             outView->appendPoint(*view, i);
         viewSet.insert(outView);
diff --git a/filters/private/DimRange.cpp b/filters/private/DimRange.cpp
index 3e5e97ba7a..f18797c515 100644
--- a/filters/private/DimRange.cpp
+++ b/filters/private/DimRange.cpp
@@ -95,7 +95,7 @@ std::string::size_type DimRange::subParse(const std::string& r)
     start = r.data() + pos;
     ub = std::strtod(start, &end);
     if (start == end)
-        ub = std::numeric_limits<double>::max();
+        ub = (std::numeric_limits<double>::max)();
     pos += (end - start);
 
     count = Utils::extractSpaces(r, pos);
@@ -159,7 +159,7 @@ std::ostream& operator<<(std::ostream& out, const DimRange& r)
     if (r.m_lower_bound != std::numeric_limits<double>::lowest())
         out << r.m_lower_bound;
     out << ':';
-    if (r.m_upper_bound != std::numeric_limits<double>::max())
+    if (r.m_upper_bound != (std::numeric_limits<double>::max)())
         out << r.m_upper_bound;
     out << (r.m_inclusive_upper_bound ? ']' : ')');
     return out;
diff --git a/io/BpfHeader.cpp b/io/BpfHeader.cpp
index d12ed82f44..97d870326d 100644
--- a/io/BpfHeader.cpp
+++ b/io/BpfHeader.cpp
@@ -373,7 +373,7 @@ bool BpfUlemFile::write(OLeStream& stream)
     char buf[MAX_BLOCKSIZE];
     while (len)
     {
-        uint32_t blocksize = std::min(MAX_BLOCKSIZE, len);
+        uint32_t blocksize = (std::min)(MAX_BLOCKSIZE, len);
         in.read(buf, blocksize);
         stream.put(buf, blocksize);
         len -= blocksize;
diff --git a/io/BpfReader.cpp b/io/BpfReader.cpp
index c3a8d158b8..9f02962aeb 100644
--- a/io/BpfReader.cpp
+++ b/io/BpfReader.cpp
@@ -563,7 +563,7 @@ point_count_t BpfReader::readByteMajor(PointViewPtr data, point_count_t count)
         uint32_t u32;
     };
     std::unique_ptr<union uu> uArr(
-        new uu[std::min(count, numPoints() - m_index)]);
+        new uu[(std::min)(count, numPoints() - m_index)]);
 
     for (size_t d = 0; d < m_dims.size(); ++d)
     {
diff --git a/io/BpfWriter.cpp b/io/BpfWriter.cpp
index 0b7f2c1ebb..69399476ab 100644
--- a/io/BpfWriter.cpp
+++ b/io/BpfWriter.cpp
@@ -353,8 +353,8 @@ double BpfWriter::getAdjustedValue(const PointView* data,
     BpfDimension& bpfDim, PointId idx)
 {
     double d = data->getFieldAs<double>(bpfDim.m_id, idx);
-    bpfDim.m_min = std::min(bpfDim.m_min, d);
-    bpfDim.m_max = std::max(bpfDim.m_max, d);
+    bpfDim.m_min = (std::min)(bpfDim.m_min, d);
+    bpfDim.m_max = (std::max)(bpfDim.m_max, d);
 
     if (bpfDim.m_id == Dimension::Id::X)
         d /= m_scaling.m_xXform.m_scale.m_val;
diff --git a/io/GDALGrid.cpp b/io/GDALGrid.cpp
index 2b01dfa871..182ecd6208 100644
--- a/io/GDALGrid.cpp
+++ b/io/GDALGrid.cpp
@@ -48,12 +48,12 @@ GDALGrid::GDALGrid(size_t width, size_t height, double edgeLength,
     m_width(width), m_height(height), m_windowSize(windowSize),
     m_edgeLength(edgeLength), m_radius(radius), m_outputTypes(outputTypes)
 {
-    if (width > std::numeric_limits<int>::max() ||
-        height > std::numeric_limits<int>::max())
+    if (width > (std::numeric_limits<int>::max)() ||
+        height > (std::numeric_limits<int>::max)())
     {
         std::ostringstream oss;
         oss << "Grid width or height is too large. Width and height are "
-            "limited to " << std::numeric_limits<int>::max() << " cells."
+            "limited to " << (std::numeric_limits<int>::max)() << " cells."
             "Try setting bounds or increasing resolution.";
         throw error(oss.str());
     }
@@ -61,7 +61,7 @@ GDALGrid::GDALGrid(size_t width, size_t height, double edgeLength,
 
     m_count.reset(new DataVec(size));
     if (m_outputTypes & statMin)
-        m_min.reset(new DataVec(size, std::numeric_limits<double>::max()));
+        m_min.reset(new DataVec(size, (std::numeric_limits<double>::max)()));
     if (m_outputTypes & statMax)
         m_max.reset(new DataVec(size, std::numeric_limits<double>::lowest()));
     if (m_outputTypes & statIdw)
@@ -119,7 +119,7 @@ void GDALGrid::expand(size_t width, size_t height, size_t xshift, size_t yshift)
 
     moveVec(m_count, 0);
     if (m_outputTypes & statMin)
-        moveVec(m_min, std::numeric_limits<double>::max());
+        moveVec(m_min, (std::numeric_limits<double>::max)());
     if (m_outputTypes & statMax)
         moveVec(m_max, std::numeric_limits<double>::lowest());
     if (m_outputTypes & statIdw)
@@ -211,8 +211,8 @@ void GDALGrid::addPoint(double x, double y, double z)
     int i, j;
     int iStart, jStart;
     // First quadrant;
-    i = iStart = std::max(0, iOrigin + 1);
-    j = std::min(jOrigin, int(m_height - 1));
+    i = iStart = (std::max)(0, iOrigin + 1);
+    j = (std::min)(jOrigin, int(m_height - 1));
     while (i < (int)m_width && j >= 0)
     {
         double d = distance(i, j, x, y);
@@ -231,8 +231,8 @@ void GDALGrid::addPoint(double x, double y, double z)
     }
 
     // Second quadrant;
-    i = std::min(iOrigin, int(m_width - 1));
-    j = jStart = std::min(jOrigin - 1, int(m_height - 1));
+    i = (std::min)(iOrigin, int(m_width - 1));
+    j = jStart = (std::min)(jOrigin - 1, int(m_height - 1));
     while (i >= 0 && j >= 0)
     {
         double d = distance(i, j, x, y);
@@ -251,8 +251,8 @@ void GDALGrid::addPoint(double x, double y, double z)
     }
 
     // Third quadrant;
-    i = iStart = std::min(iOrigin - 1, int(m_width - 1));
-    j = std::max(jOrigin, 0);
+    i = iStart = (std::min)(iOrigin - 1, int(m_width - 1));
+    j = (std::max)(jOrigin, 0);
     while (i >= 0 && j < (int)m_height)
     {
         double d = distance(i, j, x, y);
@@ -270,8 +270,8 @@ void GDALGrid::addPoint(double x, double y, double z)
         }
     }
     // Fourth quadrant;
-    i = std::max(iOrigin, 0);
-    j = jStart = std::max(jOrigin + 1, 0);
+    i = (std::max)(iOrigin, 0);
+    j = jStart = (std::max)(jOrigin + 1, 0);
     while (i < (int)m_width && j < (int)m_height)
     {
         double d = distance(i, j, x, y);
@@ -318,13 +318,13 @@ void GDALGrid::update(size_t i, size_t j, double val, double dist)
     if (m_min)
     {
         double& min = (*m_min)[offset];
-        min = std::min(val, min);
+        min = (std::min)(val, min);
     }
 
     if (m_max)
     {
         double& max = (*m_max)[offset];
-        max = std::max(val, max);
+        max = (std::max)(val, max);
     }
 
     if (m_mean)
@@ -410,9 +410,9 @@ void GDALGrid::fillNodata(size_t i)
 void GDALGrid::windowFill(size_t dstI, size_t dstJ)
 {
     size_t istart = dstI > m_windowSize ? dstI - m_windowSize : (size_t)0;
-    size_t iend = std::min(width(), dstI + m_windowSize + 1);
+    size_t iend = (std::min)(width(), dstI + m_windowSize + 1);
     size_t jstart = dstJ > m_windowSize ? dstJ - m_windowSize : (size_t)0;
-    size_t jend = std::min(height(), dstJ + m_windowSize + 1);
+    size_t jend = (std::min)(height(), dstJ + m_windowSize + 1);
 
     double distSum = 0;
     size_t dstIdx = index(dstI, dstJ);
@@ -432,7 +432,7 @@ void GDALGrid::windowFill(size_t dstI, size_t dstJ)
                 continue;
             // The ternaries just avoid underflow UB.  We're just trying to
             // find the distance from j to dstJ or i to dstI.
-            double distance = (double)std::max(j > dstJ ? j - dstJ : dstJ - j,
+            double distance = (double)(std::max)(j > dstJ ? j - dstJ : dstJ - j,
                 i > dstI ? i - dstI : dstI - i);
             windowFillCell(srcIdx, dstIdx, distance);
             distSum += (1 / distance);
diff --git a/io/GDALReader.cpp b/io/GDALReader.cpp
index 83380bc976..d37635d3d2 100644
--- a/io/GDALReader.cpp
+++ b/io/GDALReader.cpp
@@ -128,7 +128,7 @@ void GDALReader::ready(PointTableRef table)
 
 point_count_t GDALReader::read(PointViewPtr view, point_count_t num)
 {
-    point_count_t count = std::min(num, m_count - m_index);
+    point_count_t count = (std::min)(num, m_count - m_index);
     PointId nextId = view->size();
 
     std::array<double, 2> coords;
diff --git a/io/HeaderVal.hpp b/io/HeaderVal.hpp
index af4feb3c63..fa6cb08e44 100644
--- a/io/HeaderVal.hpp
+++ b/io/HeaderVal.hpp
@@ -61,7 +61,7 @@ virtual void print(const std::string& s)
 };
 
 template <typename T, T MIN = std::numeric_limits<T>::lowest(),
-    T MAX = std::numeric_limits<T>::max()>
+    T MAX = (std::numeric_limits<T>::max)()>
 class NumHeaderVal : public BaseHeaderVal<T>
 {
 public:
@@ -160,7 +160,7 @@ class StringHeaderVal : public BaseHeaderVal<std::string>
         m_valSet = true;
         m_val = val;
         if (LEN > 0)
-            m_val.resize(std::min(m_val.length(), LEN));
+            m_val.resize((std::min)(m_val.length(), LEN));
         return (LEN == 0 || val.length() <= LEN);
     }
 
diff --git a/io/LasHeader.cpp b/io/LasHeader.cpp
index a95667e815..424b6cc502 100644
--- a/io/LasHeader.cpp
+++ b/io/LasHeader.cpp
@@ -435,7 +435,7 @@ OLeStream& operator<<(OLeStream& out, const LasHeader& h)
 
     for (size_t i = 0; i < LasHeader::LEGACY_RETURN_COUNT; ++i)
     {
-        uint32_t legacyReturnCount = std::min(h.m_pointCountByReturn[i],
+        uint32_t legacyReturnCount = (std::min)(h.m_pointCountByReturn[i],
             (uint64_t)(std::numeric_limits<uint32_t>::max)());
         out << legacyReturnCount;
     }
diff --git a/io/LasReader.cpp b/io/LasReader.cpp
index aa945b1614..13cb7a87b1 100644
--- a/io/LasReader.cpp
+++ b/io/LasReader.cpp
@@ -115,7 +115,7 @@ QuickInfo LasReader::inspect()
     for (auto di = dims.begin(); di != dims.end(); ++di)
         qi.m_dimNames.push_back(layout->dimName(*di));
     if (!Utils::numericCast(m_header.pointCount(), qi.m_pointCount))
-        qi.m_pointCount = std::numeric_limits<point_count_t>::max();
+        qi.m_pointCount = (std::numeric_limits<point_count_t>::max)();
     qi.m_bounds = m_header.getBounds();
     qi.m_srs = getSpatialReference();
     qi.m_valid = true;
@@ -619,7 +619,7 @@ bool LasReader::processOne(PointRef& point)
 point_count_t LasReader::read(PointViewPtr view, point_count_t count)
 {
     size_t pointLen = m_header.pointLen();
-    count = std::min(count, getNumPoints() - m_index);
+    count = (std::min)(count, getNumPoints() - m_index);
 
     PointId i = 0;
     if (m_header.compressed())
@@ -646,8 +646,7 @@ point_count_t LasReader::read(PointViewPtr view, point_count_t count)
         point_count_t remaining = count;
 
         // Make a buffer at most a meg.
-        size_t bufsize = std::min<size_t>((point_count_t)1000000,
-            count * pointLen);
+        size_t bufsize = (std::min)((point_count_t)1000000, count * pointLen);
         std::vector<char> buf(bufsize);
         try
         {
@@ -686,7 +685,7 @@ point_count_t LasReader::readFileBlock(std::vector<char>& buf,
     size_t ptLen = m_header.pointLen();
     point_count_t blockpoints = buf.size() / ptLen;
 
-    blockpoints = std::min(maxpoints, blockpoints);
+    blockpoints = (std::min)(maxpoints, blockpoints);
     if (stream->eof())
         throw invalid_stream("stream is done");
 
diff --git a/io/LasWriter.cpp b/io/LasWriter.cpp
index b01d5bf56c..c75c3103f0 100644
--- a/io/LasWriter.cpp
+++ b/io/LasWriter.cpp
@@ -836,7 +836,7 @@ void LasWriter::writeView(const PointViewPtr view)
     else
     {
         // Make a buffer of at most a meg.
-        m_pointBuf.resize(std::min((point_count_t)1000000,
+        m_pointBuf.resize((std::min)((point_count_t)1000000,
                     pointLen * view->size()));
 
         const PointView& viewRef(*view.get());
@@ -1125,7 +1125,7 @@ point_count_t LasWriter::fillWriteBuf(const PointView& view,
     PointId startId, std::vector<char>& buf)
 {
     point_count_t blocksize = buf.size() / m_lasHeader.pointLen();
-    blocksize = std::min(blocksize, view.size() - startId);
+    blocksize = (std::min)(blocksize, view.size() - startId);
     PointId lastId = startId + blocksize;
 
     LeInserter ostream(buf.data(), buf.size());
diff --git a/io/LasWriter.hpp b/io/LasWriter.hpp
index 610cd4244e..a5b17bc0f4 100644
--- a/io/LasWriter.hpp
+++ b/io/LasWriter.hpp
@@ -111,7 +111,7 @@ class PDAL_DLL LasWriter : public FlexWriter, public Streamable
     NumHeaderVal<uint8_t, 1, 1> m_majorVersion;
     NumHeaderVal<uint8_t, 1, 4> m_minorVersion;
     NumHeaderVal<uint8_t, 0, 10> m_dataformatId;
-    // MSVC doesn't see numeric_limits::max() as constexpr do doesn't allow
+    // MSVC doesn't see numeric_limits::max() as constexpr so doesn't allow
     // it as defaults for templates.  Remove when possible.
     NumHeaderVal<uint16_t, 0, 65535> m_filesourceId;
     NumHeaderVal<uint16_t, 0, 31> m_globalEncoding;
diff --git a/io/OptechReader.cpp b/io/OptechReader.cpp
index 764f7cbf9f..bbd883a382 100644
--- a/io/OptechReader.cpp
+++ b/io/OptechReader.cpp
@@ -239,8 +239,8 @@ point_count_t OptechReader::read(PointViewPtr data,
 
 size_t OptechReader::fillBuffer()
 {
-    size_t numRecords = std::min<size_t>(m_header.numRecords - m_recordIndex,
-                                         MaxNumRecordsInBuffer);
+    size_t numRecords = (std::min)(m_header.numRecords - m_recordIndex,
+        MaxNumRecordsInBuffer);
 
     buffer_size_t bufferSize = NumBytesInRecord * numRecords;
     m_buffer.resize(bufferSize);
diff --git a/io/PlyWriter.cpp b/io/PlyWriter.cpp
index c730526a30..1900501087 100644
--- a/io/PlyWriter.cpp
+++ b/io/PlyWriter.cpp
@@ -143,9 +143,9 @@ void PlyWriter::writeHeader(PointLayoutPtr layout) const
 
 void PlyWriter::ready(PointTableRef table)
 {
-    if (pointCount() > std::numeric_limits<uint32_t>::max())
+    if (pointCount() > (std::numeric_limits<uint32_t>::max)())
         throwError("Can't write PLY file.  Only " +
-            std::to_string(std::numeric_limits<uint32_t>::max()) +
+            std::to_string((std::numeric_limits<uint32_t>::max)()) +
             " points supported.");
 
     m_stream = Utils::createFile(m_filename, true);
diff --git a/io/QfitReader.cpp b/io/QfitReader.cpp
index 69a157a01e..0b39aaef71 100644
--- a/io/QfitReader.cpp
+++ b/io/QfitReader.cpp
@@ -327,7 +327,7 @@ point_count_t QfitReader::read(PointViewPtr data, point_count_t count)
     if (m_istream->stream()->eof())
         throwError("End of file detected.");
 
-    count = std::min(m_numPoints - m_index, count);
+    count = (std::min)(m_numPoints - m_index, count);
     std::vector<char> buf(m_size);
     PointId nextId = data->size();
     point_count_t numRead = 0;
diff --git a/io/TerrasolidReader.cpp b/io/TerrasolidReader.cpp
index 591e5e371c..f8555143aa 100644
--- a/io/TerrasolidReader.cpp
+++ b/io/TerrasolidReader.cpp
@@ -142,7 +142,7 @@ void TerrasolidReader::ready(PointTableRef)
 
 point_count_t TerrasolidReader::read(PointViewPtr view, point_count_t count)
 {
-    count = std::min(count, getNumPoints() - m_index);
+    count = (std::min)(count, getNumPoints() - m_index);
 
     std::vector<char> buf(m_size * count);
     m_istream->get(buf);
diff --git a/pdal/EigenUtils.cpp b/pdal/EigenUtils.cpp
index 7dd30a909c..52a5b018ca 100644
--- a/pdal/EigenUtils.cpp
+++ b/pdal/EigenUtils.cpp
@@ -366,7 +366,7 @@ Eigen::MatrixXd matrixClose(Eigen::MatrixXd data, int radius)
     int ncols = data2.cols();
 
     MatrixXd minZ(nrows, ncols);
-    minZ.setConstant(std::numeric_limits<double>::max());
+    minZ.setConstant((std::numeric_limits<double>::max)());
     MatrixXd maxZ(nrows, ncols);
     maxZ.setConstant(std::numeric_limits<double>::lowest());
     for (auto c = 0; c < ncols; ++c)
@@ -427,7 +427,7 @@ Eigen::MatrixXd matrixOpen(Eigen::MatrixXd data, int radius)
     int ncols = data2.cols();
 
     MatrixXd minZ(nrows, ncols);
-    minZ.setConstant(std::numeric_limits<double>::max());
+    minZ.setConstant((std::numeric_limits<double>::max)());
     MatrixXd maxZ(nrows, ncols);
     maxZ.setConstant(std::numeric_limits<double>::lowest());
     for (auto c = 0; c < ncols; ++c)
@@ -514,7 +514,7 @@ std::vector<double> dilateDiamond(std::vector<double> data, size_t rows, size_t
 
 std::vector<double> erodeDiamond(std::vector<double> data, size_t rows, size_t cols, int iterations)
 {
-    std::vector<double> out(data.size(), std::numeric_limits<double>::max());
+    std::vector<double> out(data.size(), (std::numeric_limits<double>::max)());
     std::vector<size_t> idx(5);
 
     for (int iter = 0; iter < iterations; ++iter)
diff --git a/pdal/KDIndex.hpp b/pdal/KDIndex.hpp
index 6897a410a2..a3c1bee2f7 100644
--- a/pdal/KDIndex.hpp
+++ b/pdal/KDIndex.hpp
@@ -121,7 +121,7 @@ class PDAL_DLL KD2Index : public KDIndex<2>
 
     std::vector<PointId> neighbors(double x, double y, point_count_t k)
     {
-        k = std::min(m_buf.size(), k);
+        k = (std::min)(m_buf.size(), k);
         std::vector<PointId> output(k);
         std::vector<double> out_dist_sqr(k);
         nanoflann::KNNResultSet<double, PointId, point_count_t> resultSet(k);
@@ -154,7 +154,7 @@ class PDAL_DLL KD2Index : public KDIndex<2>
     void knnSearch(double x, double y, point_count_t k,
         std::vector<PointId> *indices, std::vector<double> *sqr_dists)
     {
-        k = std::min(m_buf.size(), k);
+        k = (std::min)(m_buf.size(), k);
         nanoflann::KNNResultSet<double, PointId, point_count_t> resultSet(k);
 
         resultSet.init(&indices->front(), &sqr_dists->front());
@@ -247,7 +247,7 @@ class PDAL_DLL KD3Index : public KDIndex<3>
     std::vector<PointId> neighbors(double x, double y, double z,
         point_count_t k)
     {
-        k = std::min(m_buf.size(), k);
+        k = (std::min)(m_buf.size(), k);
         std::vector<PointId> output(k);
         std::vector<double> out_dist_sqr(k);
         nanoflann::KNNResultSet<double, PointId, point_count_t> resultSet(k);
@@ -283,7 +283,7 @@ class PDAL_DLL KD3Index : public KDIndex<3>
     void knnSearch(double x, double y, double z, point_count_t k,
         std::vector<PointId> *indices, std::vector<double> *sqr_dists)
     {
-        k = std::min(m_buf.size(), k);
+        k = (std::min)(m_buf.size(), k);
         nanoflann::KNNResultSet<double, PointId, point_count_t> resultSet(k);
 
         resultSet.init(&indices->front(), &sqr_dists->front());
diff --git a/pdal/PDALUtils.cpp b/pdal/PDALUtils.cpp
index 63b23b9f69..1d328243f9 100644
--- a/pdal/PDALUtils.cpp
+++ b/pdal/PDALUtils.cpp
@@ -394,7 +394,7 @@ double computeHausdorff(PointViewPtr srcView, PointViewPtr candView)
     maxDistSrcToCand = std::sqrt(maxDistSrcToCand);
     maxDistCandToSrc = std::sqrt(maxDistCandToSrc);
 
-    return std::max(maxDistSrcToCand, maxDistCandToSrc);
+    return (std::max)(maxDistSrcToCand, maxDistCandToSrc);
 }
 
 } // namespace Utils
diff --git a/pdal/PointLayout.cpp b/pdal/PointLayout.cpp
index 4b15ab3924..f09bdfdebc 100644
--- a/pdal/PointLayout.cpp
+++ b/pdal/PointLayout.cpp
@@ -288,7 +288,7 @@ Dimension::Type PointLayout::resolveType(Dimension::Type t1,
     if (t1 == t2)
         return t1;
     if (base(t1) == base(t2))
-        return std::max(t1, t2);
+        return (std::max)(t1, t2);
     //Prefer floating to non-floating.
     if (base(t1) == BaseType::Floating && base(t2) != BaseType::Floating)
         return t1;
@@ -301,7 +301,7 @@ Dimension::Type PointLayout::resolveType(Dimension::Type t1,
     if (base(t2) == BaseType::Unsigned && size(t2) < size(t1))
         return t1;
     // Signed type is smaller or the the sizes are equal.
-    switch (std::max(size(t1), size(t2)))
+    switch ((std::max)(size(t1), size(t2)))
     {
     case 1:
         return Type::Signed16;
diff --git a/pdal/QuadIndex.cpp b/pdal/QuadIndex.cpp
index 893bcf5d8a..6af726036b 100644
--- a/pdal/QuadIndex.cpp
+++ b/pdal/QuadIndex.cpp
@@ -550,10 +550,10 @@ QuadIndex::QImpl::QImpl(const PointView& view, std::size_t topLevel)
 {
     m_pointRefVec.resize(view.size());
 
-    double xMin(std::numeric_limits<double>::max());
-    double yMin(std::numeric_limits<double>::max());
-    double xMax(std::numeric_limits<double>::min());
-    double yMax(std::numeric_limits<double>::min());
+    double xMin((std::numeric_limits<double>::max)());
+    double yMin((std::numeric_limits<double>::max)());
+    double xMax((std::numeric_limits<double>::min)());
+    double yMax((std::numeric_limits<double>::min)());
 
     for (PointId i(0); i < view.size(); ++i)
     {
@@ -575,7 +575,7 @@ QuadIndex::QImpl::QImpl(const PointView& view, std::size_t topLevel)
 
     for (std::size_t i = 0; i < m_pointRefVec.size(); ++i)
     {
-        m_depth = std::max(m_tree->addPoint(m_pointRefVec[i].get()), m_depth);
+        m_depth = (std::max)(m_tree->addPoint(m_pointRefVec[i].get()), m_depth);
     }
 }
 
@@ -608,7 +608,7 @@ QuadIndex::QImpl::QImpl(
 
     for (std::size_t i = 0; i < m_pointRefVec.size(); ++i)
     {
-        m_depth = std::max(m_tree->addPoint(m_pointRefVec[i].get()), m_depth);
+        m_depth = (std::max)(m_tree->addPoint(m_pointRefVec[i].get()), m_depth);
     }
 }
 
@@ -630,7 +630,7 @@ QuadIndex::QImpl::QImpl(
     for (std::size_t i = 0; i < points.size(); ++i)
     {
         m_pointRefVec[i] = points[i];
-        m_depth = std::max(m_tree->addPoint(m_pointRefVec[i].get()), m_depth);
+        m_depth = (std::max)(m_tree->addPoint(m_pointRefVec[i].get()), m_depth);
     }
 }
 
@@ -702,7 +702,7 @@ std::vector<PointId> QuadIndex::QImpl::getPoints(
         xEnd =      m_tree->bbox.max.x + (xStep / 2); // One tick past the end.
         yEnd =      m_tree->bbox.max.y + (yStep / 2);
 
-        results.resize(exp * exp, std::numeric_limits<PointId>::max());
+        results.resize(exp * exp, (std::numeric_limits<PointId>::max)());
 
         m_tree->getPoints(
                 results,
@@ -733,7 +733,7 @@ std::vector<PointId> QuadIndex::QImpl::getPoints(
     {
         const std::size_t width (Utils::sround((xEnd - xBegin) / xStep));
         const std::size_t height(Utils::sround((yEnd - yBegin) / yStep));
-        results.resize(width * height, std::numeric_limits<PointId>::max());
+        results.resize(width * height, (std::numeric_limits<PointId>::max)());
 
         m_tree->getPoints(
                 results,
@@ -764,8 +764,8 @@ std::vector<PointId> QuadIndex::QImpl::getPoints(
         m_tree->getPoints(
                 results,
                 BBox(
-                    Point(std::min(xMin, xMax), std::min(yMin, yMax)),
-                    Point(std::max(xMin, xMax), std::max(yMin, yMax))),
+                    Point((std::min)(xMin, xMax), (std::min)(yMin, yMax)),
+                    Point((std::max)(xMin, xMax), (std::max)(yMin, yMax))),
                 minDepth,
                 maxDepth,
                 m_topLevel);
diff --git a/pdal/Reader.cpp b/pdal/Reader.cpp
index f7fde70289..ac1720a3b5 100644
--- a/pdal/Reader.cpp
+++ b/pdal/Reader.cpp
@@ -42,7 +42,7 @@ void Reader::readerAddArgs(ProgramArgs& args)
 {
     m_filenameArg = &args.add("filename", "Name of file to read", m_filename);
     m_countArg = &args.add("count", "Maximum number of points read", m_count,
-        std::numeric_limits<point_count_t>::max());
+        (std::numeric_limits<point_count_t>::max)());
 }
 
 } // namespace pdal
diff --git a/pdal/compression/LazPerfCompression.cpp b/pdal/compression/LazPerfCompression.cpp
index ed0fa16c92..b0537e515a 100644
--- a/pdal/compression/LazPerfCompression.cpp
+++ b/pdal/compression/LazPerfCompression.cpp
@@ -116,7 +116,7 @@ class LazPerfCompressorImpl
     {
         while (bufsize)
         {
-            size_t copyCnt = std::min(m_avail, bufsize);
+            size_t copyCnt = (std::min)(m_avail, bufsize);
             std::copy(buf, buf + copyCnt, m_tmpbuf + (CHUNKSIZE - m_avail));
             m_avail -= copyCnt;
             if (m_avail == 0)
@@ -214,7 +214,7 @@ class LazPerfDecompressorImpl
 
     void getBytes(uint8_t *dst, size_t dstsize)
     {
-        size_t count = std::min(dstsize, m_srcsize);
+        size_t count = (std::min)(dstsize, m_srcsize);
         uint8_t *src = const_cast<uint8_t *>(
             reinterpret_cast<const uint8_t *>(m_srcbuf));
         std::copy(src, src + count, dst);
diff --git a/pdal/compression/LzmaCompression.cpp b/pdal/compression/LzmaCompression.cpp
index 1377ac7877..e557a484d1 100644
--- a/pdal/compression/LzmaCompression.cpp
+++ b/pdal/compression/LzmaCompression.cpp
@@ -139,7 +139,7 @@ class LzmaDecompressorImpl : public Lzma
 public:
     LzmaDecompressorImpl(BlockCb cb) : Lzma(cb)
     {
-        if (lzma_auto_decoder(&m_strm, std::numeric_limits<uint32_t>::max(),
+        if (lzma_auto_decoder(&m_strm, (std::numeric_limits<uint32_t>::max)(),
             LZMA_TELL_UNSUPPORTED_CHECK))
             throw compression_error("Can't create decompressor");
     }
diff --git a/pdal/util/Utils.cpp b/pdal/util/Utils.cpp
index 24fd630171..0eed64d561 100644
--- a/pdal/util/Utils.cpp
+++ b/pdal/util/Utils.cpp
@@ -506,7 +506,7 @@ StringList Utils::wordWrap2(std::string const& s, size_t lineLength,
     size_t startPos = 0;
     while (true)
     {
-        size_t endPos = std::min(startPos + len - 1, s.size() - 1);
+        size_t endPos = (std::min)(startPos + len - 1, s.size() - 1);
         if (endPos + 1 == s.size())
         {
             pushWord(startPos, endPos);
@@ -627,7 +627,7 @@ std::vector<std::string> Utils::backtrace()
             prefix = std::to_string(i) + "  ???";
         trimTrailing(prefix);
         prefixes.push_back(prefix);
-        maxPrefix = std::max(prefix.size(), maxPrefix);
+        maxPrefix = (std::max)(prefix.size(), maxPrefix);
     }
     free(symbols);
 
diff --git a/plugins/delaunay/filters/Delaunay_psm.cpp b/plugins/delaunay/filters/Delaunay_psm.cpp
index f6902638fb..c0e46e3e39 100644
--- a/plugins/delaunay/filters/Delaunay_psm.cpp
+++ b/plugins/delaunay/filters/Delaunay_psm.cpp
@@ -7317,7 +7317,7 @@ namespace GEO {
 #ifdef GEO_OS_WINDOWS
             return rand();
 #else
-            return int32(random() % std::numeric_limits<int32>::max());
+            return int32(random() % (std::numeric_limits<int32>::max)());
 #endif
         }
 
@@ -7329,7 +7329,7 @@ namespace GEO {
             // (problem at link time)
             return
                 float(random_int32()) /
-                float(std::numeric_limits<int32>::max());
+                float((std::numeric_limits<int32>::max)());
 #else
             return float(drand48());
 #endif
@@ -7343,7 +7343,7 @@ namespace GEO {
             // (problem at link time)
             return
                 double(random_int32()) /
-                double(std::numeric_limits<int32>::max());
+                double((std::numeric_limits<int32>::max)());
 #else
             return double(drand48());
 #endif
diff --git a/plugins/delaunay/filters/Delaunay_psm.h b/plugins/delaunay/filters/Delaunay_psm.h
index 5fdbf854dc..19787faa86 100644
--- a/plugins/delaunay/filters/Delaunay_psm.h
+++ b/plugins/delaunay/filters/Delaunay_psm.h
@@ -460,7 +460,7 @@ namespace GEO {
         typedef double float64;
 
         inline float32 max_float32() {
-            return std::numeric_limits<float32>::max();
+            return (std::numeric_limits<float32>::max)();
         }
 
         inline float32 min_float32() {
@@ -471,7 +471,7 @@ namespace GEO {
         }
 
         inline float64 max_float64() {
-            return std::numeric_limits<float64>::max();
+            return (std::numeric_limits<float64>::max)();
         }
 
         inline float64 min_float64() {
@@ -568,17 +568,17 @@ namespace GEO {
     typedef geo_index_t index_t;
 
     inline index_t max_index_t() {
-        return std::numeric_limits<index_t>::max();
+        return (std::numeric_limits<index_t>::max)();
     }
 
     typedef geo_signed_index_t signed_index_t;
 
     inline signed_index_t max_signed_index_t() {
-        return std::numeric_limits<signed_index_t>::max();
+        return (std::numeric_limits<signed_index_t>::max)();
     }
 
     inline signed_index_t min_signed_index_t() {
-        return std::numeric_limits<signed_index_t>::min();
+        return (std::numeric_limits<signed_index_t>::min)();
     }
 
     typedef geo_coord_index_t coord_index_t;
@@ -4768,8 +4768,8 @@ namespace GEO {
 #endif
             if(
                 end != s && *end == '\0' && errno == 0 &&
-                v >= std::numeric_limits<T>::min() &&
-                v <= std::numeric_limits<T>::max()
+                v >= (std::numeric_limits<T>::min)() &&
+                v <= (std::numeric_limits<T>::max)()
             ) {
                 value = static_cast<T>(v);
                 return true;
@@ -4816,7 +4816,7 @@ namespace GEO {
 #endif
             if(
                 end != s && *end == '\0' && errno == 0 &&
-                v <= std::numeric_limits<T>::max()
+                v <= (std::numeric_limits<T>::max)()
             ) {
                 value = static_cast<T>(v);
                 return true;
diff --git a/plugins/greyhound/io/bounds.cpp b/plugins/greyhound/io/bounds.cpp
index 9b6f1e2090..4500a1eda1 100644
--- a/plugins/greyhound/io/bounds.cpp
+++ b/plugins/greyhound/io/bounds.cpp
@@ -22,13 +22,13 @@ namespace entwine
 
 Bounds::Bounds(const Point& min, const Point& max)
     : m_min(
-            std::min(min.x, max.x),
-            std::min(min.y, max.y),
-            std::min(min.z, max.z))
+            (std::min)(min.x, max.x),
+            (std::min)(min.y, max.y),
+            (std::min)(min.z, max.z))
     , m_max(
-            std::max(min.x, max.x),
-            std::max(min.y, max.y),
-            std::max(min.z, max.z))
+            (std::max)(min.x, max.x),
+            (std::max)(min.y, max.y),
+            (std::max)(min.z, max.z))
     , m_mid()
 {
     setMid();
@@ -117,19 +117,19 @@ void Bounds::grow(const Bounds& other)
 
 void Bounds::grow(const Point& p)
 {
-    m_min.x = std::min(m_min.x, p.x);
-    m_min.y = std::min(m_min.y, p.y);
-    m_min.z = std::min(m_min.z, p.z);
-    m_max.x = std::max(m_max.x, p.x);
-    m_max.y = std::max(m_max.y, p.y);
-    m_max.z = std::max(m_max.z, p.z);
+    m_min.x = (std::min)(m_min.x, p.x);
+    m_min.y = (std::min)(m_min.y, p.y);
+    m_min.z = (std::min)(m_min.z, p.z);
+    m_max.x = (std::max)(m_max.x, p.x);
+    m_max.y = (std::max)(m_max.y, p.y);
+    m_max.z = (std::max)(m_max.z, p.z);
     setMid();
 }
 
 void Bounds::shrink(const Bounds& other)
 {
-    m_min = Point::max(m_min, other.min());
-    m_max = Point::min(m_max, other.max());
+    m_min = (Point::max)(m_min, other.min());
+    m_max = (Point::min)(m_max, other.max());
     setMid();
 }
 
diff --git a/plugins/greyhound/io/bounds.hpp b/plugins/greyhound/io/bounds.hpp
index db1cb98b10..53df030fd2 100644
--- a/plugins/greyhound/io/bounds.hpp
+++ b/plugins/greyhound/io/bounds.hpp
@@ -54,8 +54,8 @@ class PDAL_DLL Bounds
         setMid();
     }
 
-    const Point& min() const { return m_min; }
-    const Point& max() const { return m_max; }
+    const Point& minimum() const { return m_min; }
+    const Point& maximum() const { return m_max; }
     const Point& mid() const { return m_mid; }
 
     // Returns true if these Bounds share any area in common with another.
@@ -64,12 +64,13 @@ class PDAL_DLL Bounds
         return
             width() > 0 && depth() > 0 &&
             other.width() > 0 && other.depth() > 0 &&
-            max().x > other.min().x && min().x < other.max().x &&
-            max().y > other.min().y && min().y < other.max().y &&
+            max().x > other.minimum().x && minimum().x < other.maximum().x &&
+            max().y > other.minimum().y && minimum().y < other.maximum().y &&
             (force2d || (
                 (!height() && !other.height()) || (
                     height() > 0 && other.height() > 0 &&
-                    max().z > other.min().z && min().z < other.max().z)));
+                    maximum().z > other.minimum().z &&
+                    minimum().z < other.maximum().z)));
     }
 
     // Returns true if the requested Bounds are contained within these Bounds.
@@ -239,11 +240,12 @@ class PDAL_DLL Bounds
     }
 
     bool empty() const { return !exists(); }
-    bool exists() const { return min().exists() || max().exists(); }
+    bool exists() const { return minimum().exists() || maximum().exists(); }
     bool is3d() const { return m_min.z != m_max.z; }
 
     Json::Value toJson() const;
-    Bounds to2d() const { return Bounds(min().x, min().y, max().x, max().y); }
+    Bounds to2d() const { return Bounds(minimum().x, minimum().y,
+        maximum().x, maximum().y); }
 
     void grow(const Bounds& bounds);
     void grow(const Point& p);
@@ -261,40 +263,42 @@ class PDAL_DLL Bounds
 
     Bounds transform(const Transformation& t) const
     {
-        return Bounds(Point::transform(min(), t), Point::transform(max(), t));
+        return Bounds(Point::transform(minimum(), t),
+            Point::transform(maximum(), t));
     }
 
     Bounds intersection(const Bounds& b) const
     {
         if (!this->overlaps(b)) return Bounds();
-        return Bounds(Point::max(min(), b.min()), Point::min(max(), b.max()));
+        return Bounds(Point::maximum(minimum(), b.minimum()),
+            Point::minimum(maximum(), b.maximum()));
     }
 
     Bounds scale(const Point& scale, const Point& offset) const
     {
         return Bounds(
-                Point::scale(min(), scale, offset),
-                Point::scale(max(), scale, offset));
+                Point::scale(minimum(), scale, offset),
+                Point::scale(maximum(), scale, offset));
     }
 
     Bounds unscale(const Point& scale, const Point& offset) const
     {
         return Bounds(
-                Point::unscale(min(), scale, offset),
-                Point::unscale(max(), scale, offset));
+                Point::unscale(minimum(), scale, offset),
+                Point::unscale(maximum(), scale, offset));
     }
 
     static Bounds everything()
     {
         static const double dmin(std::numeric_limits<double>::lowest());
-        static const double dmax(std::numeric_limits<double>::max());
+        static const double dmax((std::numeric_limits<double>::max)());
         return Bounds(dmin, dmin, dmin, dmax, dmax, dmax);
     }
 
     static Bounds expander()
     {
         static const double dmin(std::numeric_limits<double>::lowest());
-        static const double dmax(std::numeric_limits<double>::max());
+        static const double dmax((std::numeric_limits<double>::max)());
 
         // Use Bounds::set to avoid malformed bounds warning.
         Bounds b;
@@ -304,12 +308,12 @@ class PDAL_DLL Bounds
 
     double operator[](std::size_t i) const
     {
-        return i < 3 ? min()[i] : max()[i - 3];
+        return i < 3 ? minimum()[i] : maximum()[i - 3];
     }
 
     Bounds make2d() const
     {
-        return Bounds(min().x, min().y, max().x, max().y);
+        return Bounds(minimum().x, minimum().y, maximum().x, maximum().y);
     }
 
 private:
@@ -342,7 +346,7 @@ PDAL_DLL inline bool operator<(const Bounds& lhs, const Bounds& rhs)
 
 PDAL_DLL inline bool operator==(const Bounds& lhs, const Bounds& rhs)
 {
-    return lhs.min() == rhs.min() && lhs.max() == rhs.max();
+    return lhs.minimum() == rhs.minimum() && lhs.maximum() == rhs.maximum();
 }
 
 PDAL_DLL inline bool operator!=(const Bounds& lhs, const Bounds& rhs)
@@ -352,7 +356,7 @@ PDAL_DLL inline bool operator!=(const Bounds& lhs, const Bounds& rhs)
 
 PDAL_DLL inline Bounds operator+(const Bounds& b, const Point& p)
 {
-    return Bounds(b.min() + p, b.max() + p);
+    return Bounds(b.minimum() + p, b.maximum() + p);
 }
 
 } // namespace entwine
diff --git a/plugins/greyhound/io/point.hpp b/plugins/greyhound/io/point.hpp
index 855dbedd49..8b38237723 100644
--- a/plugins/greyhound/io/point.hpp
+++ b/plugins/greyhound/io/point.hpp
@@ -120,20 +120,20 @@ class PDAL_DLL Point
         return 0;
     }
 
-    static Point max(const Point& a, const Point& b)
+    static Point maximum(const Point& a, const Point& b)
     {
         return Point(
-                std::max(a.x, b.x),
-                std::max(a.y, b.y),
-                std::max(a.z, b.z));
+                (std::max)(a.x, b.x),
+                (std::max)(a.y, b.y),
+                (std::max)(a.z, b.z));
     }
 
-    static Point min(const Point& a, const Point& b)
+    static Point minimum(const Point& a, const Point& b)
     {
         return Point(
-                std::min(a.x, b.x),
-                std::min(a.y, b.y),
-                std::min(a.z, b.z));
+                (std::min)(a.x, b.x),
+                (std::min)(a.y, b.y),
+                (std::min)(a.z, b.z));
     }
 
     static Point normalize(const Point& p)
@@ -385,7 +385,7 @@ inline std::ostream& operator<<(std::ostream& os, const Point& point)
 
     auto printCoord([&os](double d)
     {
-        if (d == std::numeric_limits<double>::max()) os << "max";
+        if (d == (std::numeric_limits<double>::ma)x()) os << "max";
         else if (d == std::numeric_limits<double>::lowest()) os << "min";
         else if (std::trunc(d) == d) os << static_cast<long>(d);
         else
@@ -433,20 +433,20 @@ class Color
     Color() : r(0), g(0), b(0) { }
     Color(uint8_t r, uint8_t g, uint8_t b) : r(r), g(g), b(b) { }
 
-    static Color min(const Color& a, const Color& b)
+    static Color minimum(const Color& a, const Color& b)
     {
         return Color(
-                std::min(a.r, b.r),
-                std::min(a.g, b.g),
-                std::min(a.b, b.b));
+                (std::min)(a.r, b.r),
+                (std::min)(a.g, b.g),
+                (std::min)(a.b, b.b));
     }
 
-    static Color max(const Color& a, const Color& b)
+    static Color maximum(const Color& a, const Color& b)
     {
         return Color(
-                std::max(a.r, b.r),
-                std::max(a.g, b.g),
-                std::max(a.b, b.b));
+                (std::max)(a.r, b.r),
+                (std::max)(a.g, b.g),
+                (std::max)(a.b, b.b));
     }
 
     uint8_t r, g, b;
@@ -458,6 +458,8 @@ inline std::ostream& operator<<(std::ostream& os, const Color& c)
     return os;
 }
 
+#undef STOP_EXPANSION
+
 } // namespace entwine
 } // namespace pdal
 
diff --git a/plugins/icebridge/io/Hdf5Handler.cpp b/plugins/icebridge/io/Hdf5Handler.cpp
index 0c24fdf7e8..b2df50143b 100644
--- a/plugins/icebridge/io/Hdf5Handler.cpp
+++ b/plugins/icebridge/io/Hdf5Handler.cpp
@@ -74,7 +74,7 @@ void Hdf5Handler::initialize(
                         ColumnData(predType, dataSet, dataSpace)));
 
             // Does not check whether all the columns are the same length.
-            m_numPoints = std::max((uint64_t)getColumnNumEntries(dataSetName),
+            m_numPoints = (std::max)((uint64_t)getColumnNumEntries(dataSetName),
                 m_numPoints);
         }
     }
diff --git a/plugins/icebridge/io/IcebridgeReader.cpp b/plugins/icebridge/io/IcebridgeReader.cpp
index e1dca31ec6..4407f52cc7 100644
--- a/plugins/icebridge/io/IcebridgeReader.cpp
+++ b/plugins/icebridge/io/IcebridgeReader.cpp
@@ -121,7 +121,7 @@ point_count_t IcebridgeReader::read(PointViewPtr view, point_count_t count)
 
     PointId startId = view->size();
     point_count_t remaining = m_hdf5Handler.getNumPoints() - m_index;
-    count = std::min(count, remaining);
+    count = (std::min)(count, remaining);
 
     std::unique_ptr<unsigned char>
         rawData(new unsigned char[count * sizeof(float)]);
diff --git a/plugins/mbio/io/MbReader.cpp b/plugins/mbio/io/MbReader.cpp
index 544f3a2056..152592bd86 100644
--- a/plugins/mbio/io/MbReader.cpp
+++ b/plugins/mbio/io/MbReader.cpp
@@ -91,7 +91,7 @@ void MbReader::ready(PointTableRef table)
     int lonflip = 0; // Longitude -180 -> 180
     double bounds[4] { -180, 180, -90, 90 };
     int btime_i[7] { 0, 0, 0, 0, 0, 0, 0 };
-    int etime_i[7] { std::numeric_limits<int>::max(), 0, 0, 0, 0, 0 };
+    int etime_i[7] { (std::numeric_limits<int>::max)(), 0, 0, 0, 0, 0 };
     char *mbio_ptr;
     double btime_d;
     double etime_d;
diff --git a/plugins/mrsid/io/MrsidReader.cpp b/plugins/mrsid/io/MrsidReader.cpp
index 3b7d5448ef..b8d19d29bc 100644
--- a/plugins/mrsid/io/MrsidReader.cpp
+++ b/plugins/mrsid/io/MrsidReader.cpp
@@ -183,7 +183,7 @@ QuickInfo MrsidReader::inspect()
     for (auto di = dims.begin(); di != dims.end(); ++di)
         qi.m_dimNames.push_back(layout->dimName(*di));
     if (!Utils::numericCast(m_PS->getNumPoints(), qi.m_pointCount))
-        qi.m_pointCount = std::numeric_limits<point_count_t>::max();
+        qi.m_pointCount = (std::numeric_limits<point_count_t>::max)();
     qi.m_bounds = b;
     qi.m_srs = pdal::SpatialReference(m_PS->getWKT());
     qi.m_valid = true;
diff --git a/plugins/oci/test/OCITest.cpp b/plugins/oci/test/OCITest.cpp
index ac50e9cfed..b552db4ef1 100644
--- a/plugins/oci/test/OCITest.cpp
+++ b/plugins/oci/test/OCITest.cpp
@@ -257,7 +257,7 @@ void compare(const PointViewPtr candidate, std::string filename)
     PointViewPtr source = *viewSet.begin();
 
     EXPECT_EQ(source->size(), candidate->size());
-    PointId limit = std::min(source->size(), candidate->size());
+    PointId limit = (std::min)(source->size(), candidate->size());
 
     for (PointId i = 0; i < limit; ++i)
     {
diff --git a/plugins/pcl/pipeline/PCLPipeline.hpp b/plugins/pcl/pipeline/PCLPipeline.hpp
index 20932ef9bf..699ae00983 100644
--- a/plugins/pcl/pipeline/PCLPipeline.hpp
+++ b/plugins/pcl/pipeline/PCLPipeline.hpp
@@ -79,10 +79,10 @@ pcl::Pipeline<PointT>::applyPassThrough(PointCloudConstPtr cloud,
     // parse params
     std::string field = vt["setFilterFieldName"].asString();
     float m1 = vt["setFilterLimits"]
-        .get("min", -std::numeric_limits<float>::max())
+        .get("min", -(std::numeric_limits<float>::max)())
         .asFloat();
     float m2 = vt["setFilterLimits"]
-        .get("max", std::numeric_limits<float>::max())
+        .get("max", (std::numeric_limits<float>::max)())
         .asFloat();
 
     // summarize settings
@@ -91,25 +91,25 @@ pcl::Pipeline<PointT>::applyPassThrough(PointCloudConstPtr cloud,
 
     if (field.compare("x") == 0)
     {
-        if (m1 != -std::numeric_limits<float>::max())
+        if (m1 != -(std::numeric_limits<float>::max)())
             m1 -= x_offset_;
-        if (m2 != std::numeric_limits<float>::max())
+        if (m2 != (std::numeric_limits<float>::max)())
             m2 -= x_offset_;
     }
 
     if (field.compare("y") == 0)
     {
-        if (m1 != -std::numeric_limits<float>::max())
+        if (m1 != -(std::numeric_limits<float>::max)())
             m1 -= y_offset_;
-        if (m2 != std::numeric_limits<float>::max())
+        if (m2 != (std::numeric_limits<float>::max)())
             m2 -= y_offset_;
     }
 
     if (field.compare("z") == 0)
     {
-        if (m1 != -std::numeric_limits<float>::max())
+        if (m1 != -(std::numeric_limits<float>::max)())
             m1 -= z_offset_;
-        if (m2 != std::numeric_limits<float>::max())
+        if (m2 != (std::numeric_limits<float>::max)())
             m2 -= z_offset_;
     }
 
diff --git a/plugins/rxp/io/RxpPointcloud.cpp b/plugins/rxp/io/RxpPointcloud.cpp
index 14d8f6ec34..a0206ac7d2 100644
--- a/plugins/rxp/io/RxpPointcloud.cpp
+++ b/plugins/rxp/io/RxpPointcloud.cpp
@@ -147,11 +147,11 @@ void RxpPointcloud::on_echo_transformed(echo_type echo)
         if (m_reflectanceAsIntensity) {
             uint16_t intensity;
             if (t.reflectance > m_maxReflectance) {
-                intensity = std::numeric_limits<uint16_t>::max();
+                intensity = (std::numeric_limits<uint16_t>::max)();
             } else if (t.reflectance < m_minReflectance) {
                 intensity = 0;
             } else {
-                intensity = uint16_t(std::roundf(double(std::numeric_limits<uint16_t>::max()) * 
+                intensity = uint16_t(std::roundf(double((std::numeric_limits<uint16_t>::max)()) * 
                         (t.reflectance - m_minReflectance) / (m_maxReflectance - m_minReflectance)));
             }
             m_view->setField(Id::Intensity, idx, intensity);
diff --git a/plugins/rxp/test/RxpReaderTest.cpp b/plugins/rxp/test/RxpReaderTest.cpp
index 4ff8448a6a..ad3c0f7455 100644
--- a/plugins/rxp/test/RxpReaderTest.cpp
+++ b/plugins/rxp/test/RxpReaderTest.cpp
@@ -158,5 +158,5 @@ TEST(RxpReaderTest, testReflectanceAsIntensity)
     PointViewSet viewSet = reader.execute(table);
     PointViewPtr view = *viewSet.begin();
     uint16_t intensity = view->getFieldAs<uint16_t>(Dimension::Id::Intensity, 0);
-    EXPECT_EQ(std::numeric_limits<uint16_t>::max(), intensity);
+    EXPECT_EQ((std::numeric_limits<uint16_t>::max)(), intensity);
 }
diff --git a/plugins/sqlite/io/SQLiteReader.cpp b/plugins/sqlite/io/SQLiteReader.cpp
index 7351fdea1a..386a207fe9 100644
--- a/plugins/sqlite/io/SQLiteReader.cpp
+++ b/plugins/sqlite/io/SQLiteReader.cpp
@@ -244,7 +244,7 @@ point_count_t SQLiteReader::readPatch(PointViewPtr view, point_count_t numPts)
         const char *buf = reinterpret_cast<const char *>(
             (*r)[position].blobBuf.data());
         bufsize = (*r)[position].blobBuf.size();
-        count = std::min(count, size_t(numPts));
+        count = (std::min)(count, size_t(numPts));
         LazPerfDecompressor(cb, dbDimTypes(), count).
             decompress(buf, bufsize);
 
diff --git a/test/unit/DeflateTest.cpp b/test/unit/DeflateTest.cpp
index 123c93eb81..dd4aa960f3 100644
--- a/test/unit/DeflateTest.cpp
+++ b/test/unit/DeflateTest.cpp
@@ -43,7 +43,7 @@ using namespace pdal;
 TEST(Compression, deflate)
 {
     std::default_random_engine generator;
-    std::uniform_int_distribution<int> dist(std::numeric_limits<int>::min());
+    std::uniform_int_distribution<int> dist((std::numeric_limits<int>::min)());
 
     // Choosing a size that isn't a multiple of the internal buffer.
     std::vector<int> orig(1000357);
diff --git a/test/unit/LazPerfTest.cpp b/test/unit/LazPerfTest.cpp
index ac129ed24d..c9eb650a00 100644
--- a/test/unit/LazPerfTest.cpp
+++ b/test/unit/LazPerfTest.cpp
@@ -140,7 +140,8 @@ TEST(Compression, types)
     };
     // Size is 42.
 
-    std::default_random_engine generator;std::uniform_int_distribution<int> dist(std::numeric_limits<int>::min());
+    std::default_random_engine generator;
+    std::uniform_int_distribution<int> dist((std::numeric_limits<int>::min)());
     char pts[3][42];
 
     // Fill three "points" with some random data.
diff --git a/test/unit/LzmaTest.cpp b/test/unit/LzmaTest.cpp
index 22f5d0ed53..0ba8179b47 100644
--- a/test/unit/LzmaTest.cpp
+++ b/test/unit/LzmaTest.cpp
@@ -43,7 +43,7 @@ using namespace pdal;
 TEST(Compression, lzma)
 {
     std::default_random_engine generator;
-    std::uniform_int_distribution<int> dist(std::numeric_limits<int>::min());
+    std::uniform_int_distribution<int> dist((std::numeric_limits<int>::min)());
 
     // Choosing a size that isn't a multiple of the internal buffer.
     // Trying to make something that compresses reasonably well.
diff --git a/test/unit/ZstdTest.cpp b/test/unit/ZstdTest.cpp
index c4c5f13ad7..a59d3bc9c9 100644
--- a/test/unit/ZstdTest.cpp
+++ b/test/unit/ZstdTest.cpp
@@ -43,7 +43,7 @@ using namespace pdal;
 TEST(Compression, zstd)
 {
     std::default_random_engine generator;
-    std::uniform_int_distribution<int> dist(std::numeric_limits<int>::min());
+    std::uniform_int_distribution<int> dist((std::numeric_limits<int>::min)());
 
     // Choosing a size that isn't a multiple of the internal buffer.
     // Trying to make something that compresses reasonably well.
diff --git a/test/unit/io/LasWriterTest.cpp b/test/unit/io/LasWriterTest.cpp
index 9607f018f6..a0f2b5ca5a 100644
--- a/test/unit/io/LasWriterTest.cpp
+++ b/test/unit/io/LasWriterTest.cpp
@@ -853,11 +853,11 @@ void compareFiles(const std::string& name1, const std::string& name2,
     EXPECT_EQ(d1.size(), d2.size());
     EXPECT_EQ(size1, size2);
 
-    for (PointId i = 0; i < std::min(size1, size2); i += increment)
+    for (PointId i = 0; i < (std::min)(size1, size2); i += increment)
     {
        v1->getPackedPoint(d1, i, buf1.data());
        v2->getPackedPoint(d2, i, buf2.data());
-       EXPECT_EQ(memcmp(buf1.data(), buf2.data(), std::min(size1, size2)), 0);
+       EXPECT_EQ(memcmp(buf1.data(), buf2.data(), (std::min)(size1, size2)), 0);
     }
 }
 
diff --git a/tools/lasdump/Lasdump.hpp b/tools/lasdump/Lasdump.hpp
index ce68a49280..d4ec20a882 100644
--- a/tools/lasdump/Lasdump.hpp
+++ b/tools/lasdump/Lasdump.hpp
@@ -67,7 +67,7 @@ inline int32_t cksum(const void *c, size_t size)
     while (size)
     {
         int32_t val = 0;
-        memcpy(&val, p, std::min(sizeof(int32_t), size));
+        memcpy(&val, p, (std::min)(sizeof(int32_t), size));
         sum += val;
         p++;
         if (size <= sizeof(int32_t))
diff --git a/tools/nitfwrap/NitfWrap.cpp b/tools/nitfwrap/NitfWrap.cpp
index 1ff2ffd0e3..cee1a74182 100644
--- a/tools/nitfwrap/NitfWrap.cpp
+++ b/tools/nitfwrap/NitfWrap.cpp
@@ -156,7 +156,7 @@ void NitfWrap::unwrap()
     in->seekg(offset, std::istream::beg);
     while (length)
     {
-        size_t size = std::min(length, bufsize);
+        size_t size = (std::min)(length, bufsize);
         in->read(buf.data(), size);
         out->write(buf.data(), size);
         length -= size;
diff --git a/vendor/arbiter/arbiter.cpp b/vendor/arbiter/arbiter.cpp
index 357a69b5c5..b7a200596f 100644
--- a/vendor/arbiter/arbiter.cpp
+++ b/vendor/arbiter/arbiter.cpp
@@ -3793,7 +3793,7 @@ Contents parse(const std::string& s)
         line = util::stripWhitespace(line);
         const std::size_t semiPos(line.find_first_of(';'));
         const std::size_t hashPos(line.find_first_of('#'));
-        line = line.substr(0, std::min(semiPos, hashPos));
+        line = line.substr(0, (std::min)(semiPos, hashPos));
 
         if (line.size())
         {