From eddba840ac368e1bb9fc2d329ef9a3268a37abc8 Mon Sep 17 00:00:00 2001 From: Miklos Vajna Date: Thu, 1 Oct 2015 08:31:24 +0200 Subject: basebmp: these headers are not used from other modules Change-Id: I88c5c341b88a6ea62730e5d3dd1962365c531f70 (cherry picked from commit 8e27c68847c6461c7bc0bdbff44412d6bfb0b1e8) --- basebmp/Library_basebmp.mk | 5 + basebmp/inc/accessor.hxx | 113 +++++ basebmp/inc/accessoradapters.hxx | 520 ++++++++++++++++++++ basebmp/inc/accessorfunctors.hxx | 181 +++++++ basebmp/inc/accessortraits.hxx | 126 +++++ basebmp/inc/clippedlinerenderer.hxx | 438 +++++++++++++++++ basebmp/inc/colorblendaccessoradapter.hxx | 142 ++++++ basebmp/inc/colormisc.hxx | 185 +++++++ basebmp/inc/colortraits.hxx | 144 ++++++ basebmp/inc/compositeiterator.hxx | 395 +++++++++++++++ basebmp/inc/endian.hxx | 51 ++ basebmp/inc/fillimage.hxx | 63 +++ basebmp/inc/genericcolorimageaccessor.hxx | 76 +++ basebmp/inc/greylevelformats.hxx | 129 +++++ basebmp/inc/iteratortraits.hxx | 49 ++ basebmp/inc/metafunctions.hxx | 217 +++++++++ basebmp/inc/nonstandarditerator.hxx | 39 ++ basebmp/inc/packedpixeliterator.hxx | 670 ++++++++++++++++++++++++++ basebmp/inc/paletteformats.hxx | 139 ++++++ basebmp/inc/paletteimageaccessor.hxx | 162 +++++++ basebmp/inc/pixelformatadapters.hxx | 102 ++++ basebmp/inc/pixeliterator.hxx | 349 ++++++++++++++ basebmp/inc/polypolygonrenderer.hxx | 360 ++++++++++++++ basebmp/inc/rgb24pixelformats.hxx | 92 ++++ basebmp/inc/rgbmaskpixelformats.hxx | 355 ++++++++++++++ basebmp/inc/scaleimage.hxx | 189 ++++++++ basebmp/inc/stridedarrayiterator.hxx | 108 +++++ basebmp/inc/tools.hxx | 85 ++++ basebmp/source/bitmapdevice.cxx | 36 +- basebmp/source/polypolygonrenderer.cxx | 2 +- include/basebmp/accessor.hxx | 113 ----- include/basebmp/accessoradapters.hxx | 520 -------------------- include/basebmp/accessorfunctors.hxx | 181 ------- include/basebmp/accessortraits.hxx | 126 ----- include/basebmp/clippedlinerenderer.hxx | 438 ----------------- include/basebmp/colorblendaccessoradapter.hxx | 142 ------ include/basebmp/colormisc.hxx | 185 ------- include/basebmp/colortraits.hxx | 144 ------ include/basebmp/compositeiterator.hxx | 395 --------------- include/basebmp/endian.hxx | 51 -- include/basebmp/fillimage.hxx | 63 --- include/basebmp/genericcolorimageaccessor.hxx | 76 --- include/basebmp/greylevelformats.hxx | 129 ----- include/basebmp/iteratortraits.hxx | 49 -- include/basebmp/metafunctions.hxx | 217 --------- include/basebmp/nonstandarditerator.hxx | 39 -- include/basebmp/packedpixeliterator.hxx | 670 -------------------------- include/basebmp/paletteformats.hxx | 139 ------ include/basebmp/paletteimageaccessor.hxx | 162 ------- include/basebmp/pixelformatadapters.hxx | 102 ---- include/basebmp/pixeliterator.hxx | 349 -------------- include/basebmp/polypolygonrenderer.hxx | 360 -------------- include/basebmp/rgb24pixelformats.hxx | 92 ---- include/basebmp/rgbmaskpixelformats.hxx | 355 -------------- include/basebmp/scaleimage.hxx | 189 -------- include/basebmp/stridedarrayiterator.hxx | 108 ----- include/basebmp/tools.hxx | 85 ---- 57 files changed, 5503 insertions(+), 5498 deletions(-) create mode 100644 basebmp/inc/accessor.hxx create mode 100644 basebmp/inc/accessoradapters.hxx create mode 100644 basebmp/inc/accessorfunctors.hxx create mode 100644 basebmp/inc/accessortraits.hxx create mode 100644 basebmp/inc/clippedlinerenderer.hxx create mode 100644 basebmp/inc/colorblendaccessoradapter.hxx create mode 100644 basebmp/inc/colormisc.hxx create mode 100644 basebmp/inc/colortraits.hxx create mode 100644 basebmp/inc/compositeiterator.hxx create mode 100644 basebmp/inc/endian.hxx create mode 100644 basebmp/inc/fillimage.hxx create mode 100644 basebmp/inc/genericcolorimageaccessor.hxx create mode 100644 basebmp/inc/greylevelformats.hxx create mode 100644 basebmp/inc/iteratortraits.hxx create mode 100644 basebmp/inc/metafunctions.hxx create mode 100644 basebmp/inc/nonstandarditerator.hxx create mode 100644 basebmp/inc/packedpixeliterator.hxx create mode 100644 basebmp/inc/paletteformats.hxx create mode 100644 basebmp/inc/paletteimageaccessor.hxx create mode 100644 basebmp/inc/pixelformatadapters.hxx create mode 100644 basebmp/inc/pixeliterator.hxx create mode 100644 basebmp/inc/polypolygonrenderer.hxx create mode 100644 basebmp/inc/rgb24pixelformats.hxx create mode 100644 basebmp/inc/rgbmaskpixelformats.hxx create mode 100644 basebmp/inc/scaleimage.hxx create mode 100644 basebmp/inc/stridedarrayiterator.hxx create mode 100644 basebmp/inc/tools.hxx delete mode 100644 include/basebmp/accessor.hxx delete mode 100644 include/basebmp/accessoradapters.hxx delete mode 100644 include/basebmp/accessorfunctors.hxx delete mode 100644 include/basebmp/accessortraits.hxx delete mode 100644 include/basebmp/clippedlinerenderer.hxx delete mode 100644 include/basebmp/colorblendaccessoradapter.hxx delete mode 100644 include/basebmp/colormisc.hxx delete mode 100644 include/basebmp/colortraits.hxx delete mode 100644 include/basebmp/compositeiterator.hxx delete mode 100644 include/basebmp/endian.hxx delete mode 100644 include/basebmp/fillimage.hxx delete mode 100644 include/basebmp/genericcolorimageaccessor.hxx delete mode 100644 include/basebmp/greylevelformats.hxx delete mode 100644 include/basebmp/iteratortraits.hxx delete mode 100644 include/basebmp/metafunctions.hxx delete mode 100644 include/basebmp/nonstandarditerator.hxx delete mode 100644 include/basebmp/packedpixeliterator.hxx delete mode 100644 include/basebmp/paletteformats.hxx delete mode 100644 include/basebmp/paletteimageaccessor.hxx delete mode 100644 include/basebmp/pixelformatadapters.hxx delete mode 100644 include/basebmp/pixeliterator.hxx delete mode 100644 include/basebmp/polypolygonrenderer.hxx delete mode 100644 include/basebmp/rgb24pixelformats.hxx delete mode 100644 include/basebmp/rgbmaskpixelformats.hxx delete mode 100644 include/basebmp/scaleimage.hxx delete mode 100644 include/basebmp/stridedarrayiterator.hxx delete mode 100644 include/basebmp/tools.hxx diff --git a/basebmp/Library_basebmp.mk b/basebmp/Library_basebmp.mk index 12a2dec1eb3e..809671c97c55 100644 --- a/basebmp/Library_basebmp.mk +++ b/basebmp/Library_basebmp.mk @@ -11,6 +11,11 @@ $(eval $(call gb_Library_Library,basebmp)) $(eval $(call gb_Library_use_sdk_api,basebmp)) +$(eval $(call gb_Library_set_include,basebmp,\ + -I$(SRCDIR)/basebmp/inc \ + $$(INCLUDE) \ +)) + $(eval $(call gb_Library_use_externals,basebmp,\ boost_headers \ vigra_headers \ diff --git a/basebmp/inc/accessor.hxx b/basebmp/inc/accessor.hxx new file mode 100644 index 000000000000..828d8feafdc7 --- /dev/null +++ b/basebmp/inc/accessor.hxx @@ -0,0 +1,113 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_ACCESSOR_HXX +#define INCLUDED_BASEBMP_INC_ACCESSOR_HXX + +#include + +namespace basebmp +{ + +/** Standard accessor type + + Accesses the iterator values the standard way (i.e. via + *operator()/operator[]) + */ +template class StandardAccessor +{ +public: + typedef ValueType value_type; + + + + template< class Iterator > + value_type operator()(Iterator const& i) const + { + return *i; + } + + template< class Iterator, class Difference > + value_type operator()(Iterator const& i, Difference const& diff) const + { + return i[diff]; + } + + + + template< typename V, class Iterator > + void set(V const& value, Iterator const& i) const + { + *i = vigra::detail::RequiresExplicitCast::cast(value); + } + + template< typename V, class Iterator, class Difference > + void set(V const& value, Iterator const& i, Difference const& diff) const + { + i[diff] = vigra::detail::RequiresExplicitCast::cast(value); + } +}; + + + +/** Non-standard accessor type + + Uses getter/setter methods at the given iterator type, to access + the underlying values. + */ +template class NonStandardAccessor +{ +public: + typedef ValueType value_type; + + + + template< class Iterator > + value_type operator()(Iterator const& i) const + { + return i.get(); + } + + template< class Iterator, class Difference > + value_type operator()(Iterator const& i, Difference const& diff) const + { + return i.get(diff); + } + + + + template< typename V, class Iterator > + void set(V const& value, Iterator const& i) const + { + i.set( vigra::detail::RequiresExplicitCast::cast(value) ); + } + + template< typename V, class Iterator, class Difference > + void set(V const& value, Iterator const& i, Difference const& diff) const + { + i.set( vigra::detail::RequiresExplicitCast::cast(value), + diff ); + } +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_ACCESSOR_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/accessoradapters.hxx b/basebmp/inc/accessoradapters.hxx new file mode 100644 index 000000000000..86805653e935 --- /dev/null +++ b/basebmp/inc/accessoradapters.hxx @@ -0,0 +1,520 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_ACCESSORADAPTERS_HXX +#define INCLUDED_BASEBMP_INC_ACCESSORADAPTERS_HXX + +#include + +namespace basebmp +{ + +/** Interpose given accessor's set and get methods with two unary + functors. + + @tpl WrappedAccessor + Wrapped type must provide the usual get and set accessor methods, + with the usual signatures (see StandardAccessor for a conforming + example). + + @tpl GetterFunctor + An Adaptable Unary Function (i.e. providing result_type and + argument_type typedefs) + + @tpl SetterFunctor + An Adaptable Unary Function (i.e. providing result_type and + argument_type typedefs) + */ +template< class WrappedAccessor, + typename GetterFunctor, + typename SetterFunctor > class UnaryFunctionAccessorAdapter +{ +public: + typedef typename GetterFunctor::result_type value_type; + typedef typename SetterFunctor::argument_type argument_type; + +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +// making all members public, if no member template friends +private: + template friend class UnaryFunctionAccessorAdapter; +#endif + + // we don't derive from wrapped type, to avoid ambiguities + // regarding templatized getter/setter methods. + WrappedAccessor maAccessor; + GetterFunctor maGetterFunctor; + SetterFunctor maSetterFunctor; + +public: + UnaryFunctionAccessorAdapter() : + maAccessor(), + maGetterFunctor(), + maSetterFunctor() + {} + + template< class A > explicit + UnaryFunctionAccessorAdapter( UnaryFunctionAccessorAdapter< A, + GetterFunctor, + SetterFunctor > const& rSrc ) : + maAccessor( rSrc.maAccessor ), + maGetterFunctor( rSrc.maGetterFunctor ), + maSetterFunctor( rSrc.maSetterFunctor ) + {} + + template< class T > explicit UnaryFunctionAccessorAdapter( T const& accessor ) : + maAccessor( accessor ), + maGetterFunctor(), + maSetterFunctor() + {} + + template< class T > UnaryFunctionAccessorAdapter( T accessor, + GetterFunctor getterFunctor, + SetterFunctor setterFunctor) : + maAccessor( accessor ), + maGetterFunctor( getterFunctor ), + maSetterFunctor( setterFunctor ) + {} + + + + WrappedAccessor const& getWrappedAccessor() const { return maAccessor; } + WrappedAccessor& getWrappedAccessor() { return maAccessor; } + + + + value_type getter(typename GetterFunctor::argument_type v) const + { + return maGetterFunctor(v); + } + typename SetterFunctor::result_type setter(argument_type v) const + { + return maSetterFunctor(v); + } + + + + template< class Iterator > + value_type operator()(Iterator const& i) const + { + return maGetterFunctor( maAccessor(i) ); + } + + template< class Iterator, class Difference > + value_type operator()(Iterator const& i, Difference const& diff) const + { + return maGetterFunctor( maAccessor(i,diff) ); + } + + + + template< typename V, class Iterator > + void set(V const& value, Iterator const& i) const + { + maAccessor.set( + maSetterFunctor( + vigra::detail::RequiresExplicitCast::cast(value) ), + i ); + } + + template< typename V, class Iterator, class Difference > + void set(V const& value, Iterator const& i, Difference const& diff) const + { + maAccessor.set( + maSetterFunctor( + vigra::detail::RequiresExplicitCast::cast(value) ), + i, + diff ); + } + +}; + + + +/** Interpose given accessor's set methods with a binary function, + taking both old and new value. + + The wrappee's getter methods kept as-is. + + @tpl WrappedAccessor + Wrapped type must provide the usual get and set accessor methods, + with the usual signatures (see StandardAccessor for a conforming + example). Furthermore, must provide a nested typedef value_type. + + @tpl SetterFunctor + An adaptable binary function (i.e. providing nested typedefs for + result_type and first and second argument type) + */ +template< class WrappedAccessor, + typename SetterFunctor > class BinarySetterFunctionAccessorAdapter +{ +public: + typedef typename WrappedAccessor::value_type value_type; + typedef typename SetterFunctor::second_argument_type argument_type; + +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +// making all members public, if no member template friends +private: + template friend class BinarySetterFunctionAccessorAdapter; +#endif + + WrappedAccessor maAccessor; + SetterFunctor maFunctor; + +public: + BinarySetterFunctionAccessorAdapter() : + maAccessor(), + maFunctor() + {} + + template< class A > explicit + BinarySetterFunctionAccessorAdapter( + BinarySetterFunctionAccessorAdapter< A, + SetterFunctor > const& rSrc ) : + maAccessor( rSrc.maAccessor ), + maFunctor( rSrc.maFunctor ) + {} + + template< class T > explicit BinarySetterFunctionAccessorAdapter( T const& accessor ) : + maAccessor( accessor ), + maFunctor() + {} + + template< class T > BinarySetterFunctionAccessorAdapter( T accessor, + SetterFunctor functor ) : + maAccessor( accessor ), + maFunctor( functor ) + {} + + + + WrappedAccessor const& getWrappedAccessor() const { return maAccessor; } + WrappedAccessor& getWrappedAccessor() { return maAccessor; } + + + + static typename SetterFunctor::result_type setter( + typename SetterFunctor::first_argument_type v1, + argument_type v2 ) + { + return maSetterFunctor(v1,v2); + } + + + + template< class Iterator > + value_type operator()(Iterator const& i) const + { + return maAccessor(i); + } + + template< class Iterator, class Difference > + value_type operator()(Iterator const& i, Difference const& diff) const + { + return maAccessor(i,diff); + } + + + + template< typename V, class Iterator > + void set(V const& value, Iterator const& i) const + { + maAccessor.set( + maFunctor(maAccessor(i), + vigra::detail::RequiresExplicitCast::cast(value)), + i ); + } + + template< typename V, class Iterator, class Difference > + void set(V const& value, Iterator const& i, Difference const& diff) const + { + maAccessor.set( + maFunctor(maAccessor(i,diff), + vigra::detail::RequiresExplicitCast::cast(value)), + i, + diff ); + } + +}; + + + +/** Write through a CompositeIterator's first wrapped iterator, by + piping the first wrapped iterator value, the second iterator + value, and the specified new value through a ternary function. + + Passed iterator must fulfill the CompositeIterator concept. Note + that the getter/setter methods are not templatized regarding the + iterator type, to make the mask calculation optimization below + safe (see the maskedAccessor template metafunction below) + + @tpl WrappedAccessor1 + Wrapped type must provide the usual get and set accessor methods, + with the usual signatures (see StandardAccessor for a conforming + example). Furthermore, the type must provide a nested typedef + value_type (the selection of WrappedAccessor1 as the provider for + that typedef is rather arbitrary. Could have been + WrappedAccessor2, too. So sue me) + + @tpl Functor + An adaptable ternary function (i.e. providing nested typedefs for + result_type and first, second and third argument type) + */ +template< class WrappedAccessor1, + class WrappedAccessor2, + typename Functor > class TernarySetterFunctionAccessorAdapter +{ +public: + typedef typename WrappedAccessor1::value_type value_type; + typedef typename Functor::third_argument_type argument_type; + +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +// making all members public, if no member template friends +private: + template friend class TernarySetterFunctionAccessorAdapter; +#endif + + WrappedAccessor1 ma1stAccessor; + WrappedAccessor2 ma2ndAccessor; + Functor maFunctor; + +public: + TernarySetterFunctionAccessorAdapter() : + ma1stAccessor(), + ma2ndAccessor(), + maFunctor() + {} + + template< class T > explicit TernarySetterFunctionAccessorAdapter( T const& accessor ) : + ma1stAccessor( accessor ), + ma2ndAccessor(), + maFunctor() + {} + + template< class A1, class A2 > explicit + TernarySetterFunctionAccessorAdapter( + TernarySetterFunctionAccessorAdapter< A1, + A2, + Functor > const& rSrc ) : + ma1stAccessor( rSrc.ma1stAccessor ), + ma2ndAccessor( rSrc.ma2ndAccessor ), + maFunctor( rSrc.maFunctor ) + {} + + template< class T1, class T2 > + TernarySetterFunctionAccessorAdapter( T1 accessor1, + T2 accessor2 ) : + ma1stAccessor( accessor1 ), + ma2ndAccessor( accessor2 ), + maFunctor() + {} + + template< class T1, class T2 > + TernarySetterFunctionAccessorAdapter( T1 accessor1, + T2 accessor2, + Functor func ) : + ma1stAccessor( accessor1 ), + ma2ndAccessor( accessor2 ), + maFunctor( func ) + {} + + + + WrappedAccessor1 const& get1stWrappedAccessor() const { return ma1stAccessor; } + WrappedAccessor1& get1stWrappedAccessor() { return ma1stAccessor; } + + WrappedAccessor2 const& get2ndWrappedAccessor() const { return ma2ndAccessor; } + WrappedAccessor2& get2ndWrappedAccessor() { return ma2ndAccessor; } + + + + static typename Functor::result_type setter( + typename Functor::first_argument_type v1, + typename Functor::second_argument_type v2, + argument_type v3 ) + { + return maSetterFunctor(v1,v2,v3); + } + + + + template< class Iterator > + value_type operator()(Iterator const& i) const + { + return ma1stAccessor(i.first()); + } + + template< class Iterator, class Difference > + value_type operator()(Iterator const& i, Difference const& diff) const + { + return ma1stAccessor(i.second(),diff); + } + + + + template< typename V, class Iterator > + void set(V const& value, Iterator const& i) const + { + ma1stAccessor.set( + maFunctor(ma1stAccessor(i.first()), + ma2ndAccessor(i.second()), + vigra::detail::RequiresExplicitCast::cast(value)), + i.first() ); + } + + template< typename V, class Iterator, class Difference > + void set(V const& value, Iterator const& i, Difference const& diff) const + { + ma1stAccessor.set( + maFunctor(ma1stAccessor(i.first(), diff), + ma2ndAccessor(i.second(),diff), + vigra::detail::RequiresExplicitCast::cast(value)), + i.first(), + diff ); + } + +}; + + + +/** Access two distinct images simultaneously + + Passed iterator must fulfill the CompositeIterator concept + (i.e. wrap the two image's iterators into one + CompositeIterator). The getter and setter methods expect and + return a pair of values, with types equal to the two accessors + value types + + @tpl WrappedAccessor1 + Wrapped type must provide the usual get and set accessor methods, + with the usual signatures (see StandardAccessor for a conforming + example). Furthermore, the type must provide a nested typedef + value_type. + + @tpl WrappedAccessor2 + Wrapped type must provide the usual get and set accessor methods, + with the usual signatures (see StandardAccessor for a conforming + example). Furthermore, the type must provide a nested typedef + value_type. + */ +template< class WrappedAccessor1, + class WrappedAccessor2 > class JoinImageAccessorAdapter +{ +public: + // TODO(F3): Need numeric traits and a few free functions to + // actually calculate with a pair (semantic: apply every operation + // individually to the contained types) + typedef std::pair value_type; + +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +// making all members public, if no member template friends +private: + template friend class JoinImageAccessorAdapter; +#endif + + WrappedAccessor1 ma1stAccessor; + WrappedAccessor2 ma2ndAccessor; + +public: + JoinImageAccessorAdapter() : + ma1stAccessor(), + ma2ndAccessor() + {} + + template< class T > explicit JoinImageAccessorAdapter( T const& accessor ) : + ma1stAccessor( accessor ), + ma2ndAccessor() + {} + + template< class A1, class A2 > explicit + JoinImageAccessorAdapter( + JoinImageAccessorAdapter< A1, + A2 > const& rSrc ) : + ma1stAccessor( rSrc.ma1stAccessor ), + ma2ndAccessor( rSrc.ma2ndAccessor ) + {} + + template< class T1, class T2 > + JoinImageAccessorAdapter( T1 accessor1, + T2 accessor2 ) : + ma1stAccessor( accessor1 ), + ma2ndAccessor( accessor2 ) + {} + + + + WrappedAccessor1 const& get1stWrappedAccessor() const { return ma1stAccessor; } + WrappedAccessor1& get1stWrappedAccessor() { return ma1stAccessor; } + + WrappedAccessor2 const& get2ndWrappedAccessor() const { return ma2ndAccessor; } + WrappedAccessor2& get2ndWrappedAccessor() { return ma2ndAccessor; } + + + + template< class Iterator > + value_type operator()(Iterator const& i) const + { + return std::make_pair(ma1stAccessor(i.first()), + ma2ndAccessor(i.second())); + } + + template< class Iterator, class Difference > + value_type operator()(Iterator const& i, Difference const& diff) const + { + return std::make_pair(ma1stAccessor(i.first(),diff), + ma2ndAccessor(i.second(),diff)); + } + + + + template< typename V, class Iterator > + void set(V const& value, Iterator const& i) const + { + ma1stAccessor.set( + vigra::detail::RequiresExplicitCast::cast( + value.first), + i.first() ); + ma2ndAccessor.set( + vigra::detail::RequiresExplicitCast::cast( + value.second), + i.second() ); + } + + template< typename V, class Iterator, class Difference > + void set(V const& value, Iterator const& i, Difference const& diff) const + { + ma1stAccessor.set( + vigra::detail::RequiresExplicitCast::cast( + value.first), + i.first(), + diff ); + ma2ndAccessor.set( + vigra::detail::RequiresExplicitCast::cast( + value.second), + i.second(), + diff ); + } + +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_ACCESSORADAPTERS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/accessorfunctors.hxx b/basebmp/inc/accessorfunctors.hxx new file mode 100644 index 000000000000..cae37ba7ad78 --- /dev/null +++ b/basebmp/inc/accessorfunctors.hxx @@ -0,0 +1,181 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_ACCESSORFUNCTORS_HXX +#define INCLUDED_BASEBMP_INC_ACCESSORFUNCTORS_HXX + +#include +#include + +#include + +namespace basebmp +{ + +// Some common accessor functors + + + +/// combine two values via XOR +template< typename T > struct XorFunctor : public std::binary_function +{ + T operator()( T v1, T v2 ) const { return v1 ^ v2; } +}; + + + +/// Base class, passing on the arg types +template< typename T, typename M > struct MaskFunctorBase : + public TernaryFunctorBase {}; + + +/** Let a mask flag decide between two values + + @tpl polarity + Mask polarity. When true, a false in the mask denotes + transparency, i.e. the original value will display. And vice + versa. + */ +template< typename T, + typename M, + bool polarity > struct GenericOutputMaskFunctor : public MaskFunctorBase +{ + /// Ternary mask operation - selects v1 for !m == polarity, v2 otherwise + T operator()( T v1, M m, T v2 ) const + { + return !m == polarity ? v1 : v2; + } +}; + +/** Let a mask bit decide between two values (specialization for + integer mask types) + */ +template< typename T, + typename M, + bool polarity > struct IntegerOutputMaskFunctor; +template< typename T, + typename M > struct IntegerOutputMaskFunctor : public MaskFunctorBase +{ + /** Mask v with state of m + + @return v2, if m != 0, v1 otherwise. + */ + T operator()( T v1, M m, T v2 ) const + { + typedef typename make_unsigned::type unsigned_T; + + // mask will be 0, iff m == 0, and 1 otherwise + const T mask( unsigned_cast(m | -m) >> (sizeof(unsigned_T)*8 - 1) ); + return v1*static_cast(1-mask) + v2*mask; + } +}; +template< typename T, + typename M > struct IntegerOutputMaskFunctor : public MaskFunctorBase +{ + /** Mask v with state of m + + @return v2, if m != 0, v1 otherwise. + */ + T operator()( T v1, M m, T v2 ) const + { + typedef typename make_unsigned::type unsigned_T; + + // mask will be 0, iff m == 0, and 1 otherwise + const T mask( unsigned_cast(m | -m) >> (sizeof(unsigned_T)*8 - 1) ); + return v1*mask + v2*static_cast(1-mask); + } +}; + +/** Let a mask bit decide between two values (specialization for + binary-valued mask types) + */ +template< typename T, typename M, bool polarity > struct FastIntegerOutputMaskFunctor; +template< typename T, typename M > struct FastIntegerOutputMaskFunctor : + public MaskFunctorBase +{ + /// Specialization, only valid if mask can only attain 0 or 1 + T operator()( T v1, M m, T v2 ) const + { + OSL_ASSERT(m<=1); + + return v1*static_cast(1-m) + v2*m; + } +}; +template< typename T, typename M > struct FastIntegerOutputMaskFunctor : + public MaskFunctorBase +{ + /// Specialization, only valid if mask can only attain 0 or 1 + T operator()( T v1, M m, T v2 ) const + { + OSL_ASSERT(m<=1); + + return v1*m + v2*static_cast(1-m); + } +}; + + + +/** Split a pair value from a JoinImageAccessorAdapter into its + individual values, and pass it on to a ternary functor + + This wrapper is an adaptable binary functor, and can thus be used + with a BinarySetterFunctionAccessorAdapter. Useful e.g. for + out-of-image alpha channel, or a masked image. + + @tpl Functor + An adaptable ternary functor (as can e.g. be passed to the + TernarySetterFunctionAccessorAdapter) + */ +template< typename Functor > struct BinaryFunctorSplittingWrapper : + public std::binary_function, + typename Functor::result_type> +{ +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +// making all members public, if no member template friends +private: + template friend struct BinaryFunctorSplittingWrapper; +#endif + Functor maFunctor; + +public: + BinaryFunctorSplittingWrapper() : maFunctor() {} + + template< class A > explicit + BinaryFunctorSplittingWrapper( + BinaryFunctorSplittingWrapper const& src ) : maFunctor(src.maFunctor) {} + + template< class F > explicit + BinaryFunctorSplittingWrapper( F const& func ) : maFunctor(func) {} + + typename Functor::result_type operator()( + typename Functor::first_argument_type v1, + std::pair< typename Functor::third_argument_type, + typename Functor::second_argument_type > const& v2 ) const + { + return maFunctor( v1, v2.second, v2.first ); + } +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_ACCESSORFUNCTORS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/accessortraits.hxx b/basebmp/inc/accessortraits.hxx new file mode 100644 index 000000000000..24a7af2408a6 --- /dev/null +++ b/basebmp/inc/accessortraits.hxx @@ -0,0 +1,126 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_ACCESSORTRAITS_HXX +#define INCLUDED_BASEBMP_INC_ACCESSORTRAITS_HXX + +#include +#include +#include + +#include + +#include + +namespace basebmp +{ + +struct FastMask; +struct NoFastMask; + +/// Metafunction to select output mask functor from iterator and mask value type +template< typename T, typename M, bool polarity, typename DUMMY > struct outputMaskFunctorSelector : public + ifBothScalarIntegral< T, M, + IntegerOutputMaskFunctor< T, M, polarity >, + GenericOutputMaskFunctor< T, M, polarity > > +{ +}; +template< typename T, typename M, bool polarity > struct outputMaskFunctorSelector< T, M, polarity, FastMask > : public + ifBothScalarIntegral< T, M, + FastIntegerOutputMaskFunctor< T, M, polarity >, + GenericOutputMaskFunctor< T, M, polarity > > +{ +}; + +/** Metafunction providing a point of configuration for iterators + capable of employing the fast output mask functor. + + Specialize this metafunction for your case, and pass FastMask to + the outputMaskFunctorSelector. + */ +template< class Accessor, + class MaskAccessor, + class Iterator, + class MaskIterator, + bool polarity > struct maskedAccessorSelector +{ + typedef TernarySetterFunctionAccessorAdapter< + Accessor, + MaskAccessor, + typename outputMaskFunctorSelector< + typename Accessor::value_type, + typename MaskAccessor::value_type, + polarity, + NoFastMask > ::type > + type; +}; + + + +/** Traits template for Accessor + + Provides wrapped types for color lookup, raw pixel access, xor and + mask accessors. + */ +template< class Accessor > struct AccessorTraits +{ + /// value type of described accessor + typedef typename Accessor::value_type value_type; + + /// Retrieve stand-alone color lookup function for given Accessor type + typedef o3tl::project2nd< Accessor, value_type > color_lookup; + + /// Retrieve raw pixel data accessor for given Accessor type + typedef Accessor raw_accessor; + + /// Retrieve wrapped accessor for XOR setter access + typedef BinarySetterFunctionAccessorAdapter< + Accessor, + XorFunctor< value_type > > xor_accessor; + + /** Retrieve masked accessor for given types + + A masked accessor works like a filter, where the mask gates + the accessor's setter methods (if the mask contains a 0 at a + given iterator position, the original value is + preserved. Otherwise, the new value gets set). + + @attention be careful when retrieving a masked accessor for a + set of types, and using it for a different one - there are + partial specializations that take an optimized functor for + certain mask accessors. + */ + template< class MaskAccessor, + class Iterator, + class MaskIterator, + bool polarity > struct masked_accessor : + public maskedAccessorSelector< Accessor, + MaskAccessor, + Iterator, + MaskIterator, + polarity > + {}; + +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_ACCESSORTRAITS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/clippedlinerenderer.hxx b/basebmp/inc/clippedlinerenderer.hxx new file mode 100644 index 000000000000..e8638720e8c6 --- /dev/null +++ b/basebmp/inc/clippedlinerenderer.hxx @@ -0,0 +1,438 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_CLIPPEDLINERENDERER_HXX +#define INCLUDED_BASEBMP_INC_CLIPPEDLINERENDERER_HXX + +#include +#include +#include + +#include +#include + +namespace basebmp +{ + +// factored-out bresenham setup code, which is used from two different +// places in renderClippedLine() below. Admittedly messy for the long +// parameter list... +inline bool prepareClip( sal_Int32 a1, + sal_Int32 a2, + sal_Int32 b1, + sal_Int32 da, + sal_Int32 db, + sal_Int32& o_as, + sal_Int32& o_bs, + int sa, + int sb, + sal_Int32& io_rem, + int& o_n, + sal_uInt32 clipCode1, + sal_uInt32 clipCount1, + sal_uInt32 clipCode2, + sal_uInt32 clipCount2, + sal_Int32 aMin, + sal_uInt32 aMinFlag, + sal_Int32 aMax, + sal_uInt32 aMaxFlag, + sal_Int32 bMin, + sal_uInt32 bMinFlag, + sal_Int32 bMax, + sal_uInt32 bMaxFlag, + bool bRoundTowardsPt2, + bool& o_bUseAlternateBresenham ) +{ + int ca(0), cb(0); + if( clipCode1 ) + { + if( clipCode1 & aMinFlag ) + { + ca = 2*db*(aMin - a1); + o_as = aMin; + } + else if( clipCode1 & aMaxFlag ) + { + ca = 2*db*(a1 - aMax); + o_as = aMax; + } + + if( clipCode1 & bMinFlag ) + { + cb = 2*da*(bMin - b1); + o_bs = bMin; + } + else if( clipCode1 & bMaxFlag ) + { + cb = 2*da*(b1 - bMax); + o_bs = bMax; + } + + if( clipCount1 == 2 ) + clipCode1 &= (ca + da < cb + int(!bRoundTowardsPt2)) ? ~(aMinFlag|aMaxFlag) : ~(bMinFlag|bMaxFlag); + + if( clipCode1 & (aMinFlag|aMaxFlag) ) + { + sal_Int32 da2 = 2*da; + + if (da2 == 0) + return false; // overflow + + cb = (ca + da - int(!bRoundTowardsPt2)) / (da2); + + if( sb >= 0 ) + { + o_bs = b1 + cb; + if( o_bs > bMax ) + return false; // fully clipped + } + else + { + o_bs = b1 - cb; + if( o_bs < bMin ) + return false; // fully clipped + } + + io_rem += ca - da2*cb; + } + else + { + sal_Int32 db2 = 2*db; + + if (db2 == 0) + return false; // overflow + + ca = (cb - da + db2 - int(bRoundTowardsPt2)) / (db2); + if( sa >= 0 ) + { + o_as = a1 + ca; + if( o_as > aMax ) + return false; // fully clipped + } + else + { + o_as = a1 - ca; + if( o_as < aMin ) + return false; // fully clipped + } + + io_rem += db2*ca - cb; + } + } + else + { + o_as = a1; o_bs = b1; + } + + if( clipCode2 ) + { + if( clipCount2 == 2 ) + { + ca = 2*db*((clipCode2 & aMinFlag) ? a1 - aMin : aMax - a1); + cb = 2*da*((clipCode2 & bMinFlag) ? b1 - bMin : bMax - b1); + clipCode2 &= (cb + da < ca + int(bRoundTowardsPt2)) ? ~(aMinFlag|aMaxFlag) : ~(bMinFlag|bMaxFlag); + } + + if( clipCode2 & (aMinFlag|aMaxFlag) ) + o_n = (clipCode2 & aMinFlag) ? o_as - aMin : aMax - o_as; + else + { + o_n = (clipCode2 & bMinFlag) ? o_bs - bMin : bMax - o_bs; + o_bUseAlternateBresenham = true; + } + } + else + o_n = (a2 >= o_as) ? a2 - o_as : o_as - a2; + + return true; // at least one pixel to render +} + + +/** Render line to image iterators, clip against given rectangle + + This method renders a line from aPt1 to aPt2, clipped against + rClipRect (the clipping will take place pixel-perfect, i.e. as if + the original bresenham-rendered line would have been clipped each + pixel individually. No slight shifts compared to unclipped lines). + + @param aPt1 + Start point of the line + + @param aPt2 + End point of the line + + @param rClipRect + Rectangle to clip against + + @param color + Color value to render the line with + + @param begin + left-top image iterator + + @param end + right-bottom image iterator + + @param acc + Image accessor + + @param bRoundTowardsPt2 + Rounding mode to use. Giving false here results in line pixel tend + towards pt1, i.e. when a pixel exactly hits the middle between two + pixel, the pixel closer to pt1 will be chosen. Giving true here + makes renderClippedLine() choose pt2 in those cases. + */ +template< class Iterator, class Accessor > +void renderClippedLine( basegfx::B2IPoint aPt1, + basegfx::B2IPoint aPt2, + const basegfx::B2IBox& rClipRect, + typename Accessor::value_type color, + Iterator begin, + Accessor acc, + bool bRoundTowardsPt2=false ) +{ + // Algorithm according to Steven Eker's 'Pixel-perfect line clipping', + // Graphics Gems V, pp. 314-322 + sal_uInt32 clipCode1 = basegfx::tools::getCohenSutherlandClipFlags(aPt1, + rClipRect); + sal_uInt32 clipCode2 = basegfx::tools::getCohenSutherlandClipFlags(aPt2, + rClipRect); + + if( clipCode1 & clipCode2 ) + return; // line fully clipped away, both endpoints share a half-plane + + sal_uInt32 clipCount1 = basegfx::tools::getNumberOfClipPlanes(clipCode1); + sal_uInt32 clipCount2 = basegfx::tools::getNumberOfClipPlanes(clipCode2); + + if( (clipCode1 != 0 && clipCode2 == 0) + || (clipCount1 == 2 && clipCount2 == 1) ) + { + std::swap(clipCount2,clipCount1); + std::swap(clipCode2,clipCode1); + std::swap(aPt1,aPt2); + bRoundTowardsPt2 = !bRoundTowardsPt2; + } + + const sal_Int32 x1 = aPt1.getX(); + const sal_Int32 x2 = aPt2.getX(); + const sal_Int32 y1 = aPt1.getY(); + const sal_Int32 y2 = aPt2.getY(); + + // TODO(E1): This might overflow + sal_Int32 adx = x2 - x1; + int sx = 1; + if( adx < 0 ) + { + adx *= -1; + sx = -1; + } + + // TODO(E1): This might overflow + sal_Int32 ady = y2 - y1; + int sy = 1; + if( ady < 0 ) + { + ady *= -1; + sy = -1; + } + + int n = 0; + sal_Int32 xs = x1; + sal_Int32 ys = y1; + bool bUseAlternateBresenham=false; + + sal_Int32 nMinY(rClipRect.getMinY()); + sal_Int32 nMaxY(rClipRect.getMaxY()-1); + sal_Int32 nMinX(rClipRect.getMinX()); + sal_Int32 nMaxX(rClipRect.getMaxX()-1); + + if( adx >= ady ) + { + // semi-horizontal line + sal_Int32 rem = 2*ady - adx - int(!bRoundTowardsPt2); + + if( !prepareClip(x1, x2, y1, adx, ady, xs, ys, sx, sy, + rem, n, clipCode1, clipCount1, clipCode2, clipCount2, + nMinX, basegfx::tools::RectClipFlags::LEFT, + nMaxX, basegfx::tools::RectClipFlags::RIGHT, + nMinY, basegfx::tools::RectClipFlags::TOP, + nMaxY, basegfx::tools::RectClipFlags::BOTTOM, + bRoundTowardsPt2, bUseAlternateBresenham ) ) + return; // line fully clipped away, no active pixel inside rect + + Iterator currIter( begin + vigra::Diff2D(0,ys) ); + typename vigra::IteratorTraits::row_iterator + rowIter( currIter.rowIterator() + xs ); + + adx *= 2; + ady *= 2; + + if( bUseAlternateBresenham ) + { + if (rem < 0 && ady <= 0) + return; //break will never be hit under these circumstances + + while(true) + { + if (xs >= nMinX && xs <= nMaxX && ys >= nMinY && ys <= nMaxY) + acc.set(color, rowIter); + + if( rem >= 0 ) + { + // this is intended - we clip endpoint against y + // plane, so n here denotes y range to render + if( --n < 0 ) + break; + + ys += sy; + xs += sx; + rem -= adx; + + currIter.y += sy; + rowIter = currIter.rowIterator() + xs; + } + else + { + xs += sx; + rowIter += sx; + } + + rem += ady; + } + } + else + { + while(true) + { + if (xs >= nMinX && xs <= nMaxX && ys >= nMinY && ys <= nMaxY) + acc.set(color, rowIter); + + if( --n < 0 ) + break; + + if( rem >= 0 ) + { + ys += sy; + xs += sx; + rem -= adx; + + currIter.y += sy; + rowIter = currIter.rowIterator() + xs; + } + else + { + xs += sx; + rowIter += sx; + } + + rem += ady; + } + } + } + else + { + // semi-vertical line + sal_Int32 rem = 2*adx - ady - int(!bRoundTowardsPt2); + + if( !prepareClip(y1, y2, x1, ady, adx, ys, xs, sy, sx, + rem, n, clipCode1, clipCount1, clipCode2, clipCount2, + nMinY, basegfx::tools::RectClipFlags::TOP, + nMaxY, basegfx::tools::RectClipFlags::BOTTOM, + nMinX, basegfx::tools::RectClipFlags::LEFT, + nMaxY, basegfx::tools::RectClipFlags::RIGHT, + bRoundTowardsPt2, bUseAlternateBresenham ) ) + return; // line fully clipped away, no active pixel inside rect + + Iterator currIter( begin + vigra::Diff2D(xs,0) ); + typename vigra::IteratorTraits::column_iterator + colIter( currIter.columnIterator() + ys ); + + adx *= 2; + ady *= 2; + + if( bUseAlternateBresenham ) + { + if (rem < 0 && adx <= 0) + return; //break will never be hit under these circumstances + + while(true) + { + if (xs >= nMinX && xs <= nMaxX && ys >= nMinY && ys <= nMaxY) + acc.set(color, colIter); + + if( rem >= 0 ) + { + // this is intended - we clip endpoint against x + // plane, so n here denotes x range to render + if( --n < 0 ) + break; + + xs += sx; + ys += sy; + + rem -= ady; + + currIter.x += sx; + colIter = currIter.columnIterator() + ys; + } + else + { + ys += sy; + colIter += sy; + } + + rem += adx; + } + } + else + { + while(true) + { + if (xs >= nMinX && xs <= nMaxX && ys >= nMinY && ys <= nMaxY) + acc.set(color, colIter); + + if( --n < 0 ) + break; + + if( rem >= 0 ) + { + xs += sx; + ys += sy; + rem -= ady; + + currIter.x += sx; + colIter = currIter.columnIterator() + ys; + } + else + { + ys += sy; + colIter += sy; + } + + rem += adx; + } + } + } +} + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_CLIPPEDLINERENDERER_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/colorblendaccessoradapter.hxx b/basebmp/inc/colorblendaccessoradapter.hxx new file mode 100644 index 000000000000..b9465fb4a584 --- /dev/null +++ b/basebmp/inc/colorblendaccessoradapter.hxx @@ -0,0 +1,142 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_COLORBLENDACCESSORADAPTER_HXX +#define INCLUDED_BASEBMP_INC_COLORBLENDACCESSORADAPTER_HXX + +#include + +namespace basebmp +{ + +/** Accessor adapter that blends input value against fixed color value + + Used to blend an alpha mask 'through' a fixed color value into the + destination. + + The getter functors return a constant value (usually the zero of + the value type, this preserves the original destination content + when blitting through a mask) - there really isn't no other + sensible default behaviour for these methods. + */ +template< class WrappedAccessor, + typename AlphaType, + bool polarity > class ConstantColorBlendSetterAccessorAdapter +{ +public: + typedef AlphaType alpha_type; + typedef AlphaType value_type; + typedef typename WrappedAccessor::value_type color_type; + +private: + typename ColorTraits< color_type >:: + template blend_functor::type maFunctor; + WrappedAccessor maWrappee; + color_type maBlendColor; + value_type maGetterValue; + +public: + ConstantColorBlendSetterAccessorAdapter() : + maFunctor(), + maWrappee(), + maBlendColor(), + maGetterValue() + {} + + template< class T > explicit ConstantColorBlendSetterAccessorAdapter( T acc ) : + maFunctor(), + maWrappee(acc), + maBlendColor(), + maGetterValue() + {} + + template< class T > ConstantColorBlendSetterAccessorAdapter( T acc, + color_type col ) : + maFunctor(), + maWrappee(acc), + maBlendColor(col), + maGetterValue() + {} + + template< class T > ConstantColorBlendSetterAccessorAdapter( T acc, + color_type col, + value_type val ) : + maFunctor(), + maWrappee(acc), + maBlendColor(col), + maGetterValue(val) + {} + + + + void setColor( color_type col ) { maBlendColor=col; } + color_type getColor() { return maBlendColor; } + void setGetterValue( value_type val ) { maGetterValue=val; } + value_type getGetterValue() { return maGetterValue; } + + + + WrappedAccessor const& getWrappedAccessor() const { return maWrappee; } + WrappedAccessor& getWrappedAccessor() { return maWrappee; } + + + + /// @return constant value, regardless of iterator content + template< typename IteratorType > value_type operator()(SAL_UNUSED_PARAMETER IteratorType const& ) const + { + return maGetterValue; + } + /// @return constant value, regardless of iterator content + template< typename IteratorType, class Difference > + value_type operator()(SAL_UNUSED_PARAMETER IteratorType const& , SAL_UNUSED_PARAMETER Difference const& ) const + { + return maGetterValue; + } + + + + template< typename V, typename IteratorType > + void set(V const& value, IteratorType const& i) const + { + maWrappee.set( + maFunctor( + vigra::detail::RequiresExplicitCast::cast(value), + maWrappee(i), + maBlendColor), + i ); + } + + template< typename V, typename IteratorType, class Difference > + void set(V const& value, IteratorType const& i, Difference const& diff) const + { + maWrappee.set( + maFunctor( + vigra::detail::RequiresExplicitCast::cast(value), + maWrappee(i,diff), + maBlendColor), + i, + diff ); + } +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_COLORBLENDACCESSORADAPTER_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/colormisc.hxx b/basebmp/inc/colormisc.hxx new file mode 100644 index 000000000000..84b9d85b012e --- /dev/null +++ b/basebmp/inc/colormisc.hxx @@ -0,0 +1,185 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_COLORMISC_HXX +#define INCLUDED_BASEBMP_INC_COLORMISC_HXX + +#include +#include +#include +#include +#include + +// Contents of this header moved out of color.hxx, as it is not useful +// for the general public (drags in vigra and other template +// functionality, that shouldn't be necessary for the ordinary client +// of BitmapDevice etc.) + +namespace basebmp +{ + +template< bool polarity > struct ColorBitmaskOutputMaskFunctor; +template<> struct ColorBitmaskOutputMaskFunctor : MaskFunctorBase +{ + Color operator()( Color v1, sal_uInt8 m, Color v2 ) const + { + OSL_ASSERT(m<=1); + + return Color(v1.toInt32()*(sal_uInt8)(1-m) + v2.toInt32()*m); + } +}; +template<> struct ColorBitmaskOutputMaskFunctor : MaskFunctorBase +{ + Color operator()( Color v1, sal_uInt8 m, Color v2 ) const + { + OSL_ASSERT(m<=1); + + return Color(v1.toInt32()*m + v2.toInt32()*(sal_uInt8)(1-m)); + } +}; + +/// Specialized output mask functor for Color value type +template struct outputMaskFunctorSelector< Color, sal_uInt8, polarity, FastMask > +{ + typedef ColorBitmaskOutputMaskFunctor type; +}; + +template< bool polarity > struct ColorBlendFunctor8 + : public TernaryFunctorBase +{ + Color operator()( sal_uInt8 alpha, + Color v1, + Color v2 ) const + { + alpha = polarity ? alpha : 255 - alpha; + + const sal_uInt8 v1_red( v1.getRed() ); + const sal_uInt8 v1_green( v1.getGreen() ); + const sal_uInt8 v1_blue( v1.getBlue() ); + + // using '>> 8' instead of '/ 0x100' is ill-advised (shifted + // value might be negative). Better rely on decent optimizer + // here... + return Color(((((sal_Int32)v2.getRed() - v1_red)*alpha) / 0x100) + v1_red, + ((((sal_Int32)v2.getGreen() - v1_green)*alpha) / 0x100) + v1_green, + ((((sal_Int32)v2.getBlue() - v1_blue)*alpha) / 0x100) + v1_blue); + } +}; + +template< bool polarity > struct ColorBlendFunctor32 + : public TernaryFunctorBase +{ + Color operator()( Color input, + Color v1, + Color v2 ) const + { + sal_uInt8 alpha = input.getGreyscale(); + alpha = polarity ? alpha : 255 - alpha; + + const sal_uInt8 v1_red( v1.getRed() ); + const sal_uInt8 v1_green( v1.getGreen() ); + const sal_uInt8 v1_blue( v1.getBlue() ); + + // using '>> 8' instead of '/ 0x100' is ill-advised (shifted + // value might be negative). Better rely on decent optimizer + // here... + return Color(((((sal_Int32)v2.getRed() - v1_red)*alpha) / 0x100) + v1_red, + ((((sal_Int32)v2.getGreen() - v1_green)*alpha) / 0x100) + v1_green, + ((((sal_Int32)v2.getBlue() - v1_blue)*alpha) / 0x100) + v1_blue); + } +}; + + + +template<> struct ColorTraits< Color > +{ + /// @return number of color channels + static int numChannels() { return 3; } + + /// Type of a color component (i.e. the type of an individual channel) + typedef sal_uInt8 component_type; + + /// Metafunction to select blend functor from color and alpha type + template< typename AlphaType, bool polarity > struct blend_functor; + + /// Calculate normalized distance between color c1 and c2 + static inline double distance( const Color& c1, + const Color& c2 ) + { + return (c1 - c2).magnitude(); + } + + static inline component_type toGreyscale( const Color& c ) + { + return c.getGreyscale(); + } + + static inline Color fromGreyscale( component_type c ) + { + return Color(c,c,c); + } +}; + +/// The version for plain 8 bit alpha +template struct ColorTraits< Color >::blend_functor< sal_uInt8, polarity > +{ + typedef ColorBlendFunctor8 type; +}; + +/// The version taking grey value of a Color +template struct ColorTraits< Color >::blend_functor< Color, polarity > +{ + typedef ColorBlendFunctor32 type; +}; + +} // namespace basebmp + +namespace vigra +{ + +template<> +struct NumericTraits +{ + typedef basebmp::Color Type; + typedef basebmp::Color Promote; + typedef basebmp::Color RealPromote; + typedef std::complex ComplexPromote; + typedef sal_uInt8 ValueType; + + typedef VigraTrueType isIntegral; + typedef VigraFalseType isScalar; + typedef VigraTrueType isSigned; + typedef VigraTrueType isOrdered; + typedef VigraFalseType isComplex; + + static Type zero() { return Type(); } + static Type one() { return Type(0x01010101); } + static Type nonZero() { return Type(0x01010101); } + + static Promote toPromote(const Type& v) { return v; } + static RealPromote toRealPromote(const Type& v) { return v; } + static Type fromPromote(const Promote& v) { return v; } + static Type fromRealPromote(const RealPromote& v) { return v; } +}; + +} // namespace vigra + +#endif /* INCLUDED_BASEBMP_INC_COLORMISC_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/colortraits.hxx b/basebmp/inc/colortraits.hxx new file mode 100644 index 000000000000..5cbfeede0db5 --- /dev/null +++ b/basebmp/inc/colortraits.hxx @@ -0,0 +1,144 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_COLORTRAITS_HXX +#define INCLUDED_BASEBMP_INC_COLORTRAITS_HXX + +#include +#include + +#include + +namespace basebmp +{ + +/** Functor template, to calculate alpha blending between two + values. Float case. + + @tpl polarity + When true, 0 means fully transparent, and 1 fully opaque. And vice + versa. + */ +template< typename ValueType, + typename AlphaType, + bool polarity > struct BlendFunctor; +template< typename ValueType, + typename AlphaType > struct BlendFunctor + : public TernaryFunctorBase +{ + ValueType operator()( AlphaType alpha, + ValueType v1, + ValueType v2 ) const + { + const typename vigra::NumericTraits::RealPromote fAlpha( + vigra::NumericTraits::toRealPromote(alpha)); + return (vigra::NumericTraits::one()-fAlpha)*v1 + fAlpha*v2; + } +}; +template< typename ValueType, + typename AlphaType > struct BlendFunctor + : public TernaryFunctorBase +{ + ValueType operator()( AlphaType alpha, + ValueType v1, + ValueType v2 ) const + { + const typename vigra::NumericTraits::RealPromote fAlpha( + vigra::NumericTraits::toRealPromote(alpha)); + return fAlpha*v1 + (vigra::NumericTraits::one()-fAlpha)*v2; + } +}; + +/** Functor template, to calculate alpha blending between two + values. Integer case. + + @tpl polarity + When true, 0 means fully transparent, and 1 fully opaque. And vice + versa. + */ +template< typename ValueType, + typename AlphaType, + bool polarity > struct IntegerBlendFunctor; +template< typename ValueType, + typename AlphaType > struct IntegerBlendFunctor + : public TernaryFunctorBase +{ + ValueType operator()( AlphaType alpha, + ValueType v1, + ValueType v2 ) const + { + return (vigra::NumericTraits::toPromote( + vigra::NumericTraits::max()-alpha)*v1 + alpha*v2) / + vigra::NumericTraits::max(); + } +}; +template< typename ValueType, + typename AlphaType > struct IntegerBlendFunctor + : public TernaryFunctorBase +{ + ValueType operator()( AlphaType alpha, + ValueType v1, + ValueType v2 ) const + { + return (alpha*v1 + + vigra::NumericTraits::toPromote( + vigra::NumericTraits::max()-alpha)*v2) / + vigra::NumericTraits::max(); + } +}; + + + +template< typename ColorType > struct ColorTraits +{ + /// Metafunction to select blend functor from color and alpha type + template< typename AlphaType, bool polarity > struct blend_functor : public + ifScalarIntegral< AlphaType, + IntegerBlendFunctor< ColorType, AlphaType, polarity >, + BlendFunctor< ColorType, AlphaType, polarity > > {}; + + /// @return number of color channels + static int numChannels() { return 1; } + + /// Type of a color component (i.e. the type of an individual channel) + typedef ColorType component_type; + + /// Calculate normalized distance between color c1 and c2 + static inline vigra::NormTraits distance( ColorType c1, + ColorType c2 ) + { + return vigra::norm(c1 - c2); + } + + static inline component_type toGreyscale( ColorType c ) + { + return c; + } + + static inline ColorType fromGreyscale( component_type c ) + { + return c; + } +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_COLORTRAITS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/compositeiterator.hxx b/basebmp/inc/compositeiterator.hxx new file mode 100644 index 000000000000..2db654aa093d --- /dev/null +++ b/basebmp/inc/compositeiterator.hxx @@ -0,0 +1,395 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_COMPOSITEITERATOR_HXX +#define INCLUDED_BASEBMP_INC_COMPOSITEITERATOR_HXX + +#include +#include + +#include +#include +#include + + +namespace basebmp +{ + +namespace detail +{ + template< typename T1, typename T2 > class ArithmeticProxy + { + public: + ArithmeticProxy(T1& val1, T2& val2) : + mpVal1( &val1 ), + mpVal2( &val2 ) + {} + + void operator++() { ++(*mpVal1); ++(*mpVal2); } + void operator++(int) { (*mpVal1)++; (*mpVal2)++; } + void operator--() { --(*mpVal1); --(*mpVal2); } + void operator--(int) { (*mpVal1)--; (*mpVal2)--; } + void operator+=(int d) {*mpVal1+=d; *mpVal2+=d; } + void operator-=(int d) {*mpVal1-=d; *mpVal2-=d; } + + bool operator==(ArithmeticProxy const & rhs) const + { return *mpVal1==*rhs.mpVal1 && *mpVal2==*rhs.mpVal2; } + + bool operator!=(ArithmeticProxy const & rhs) const + { return *mpVal1!=*rhs.mpVal1 || *mpVal2!=*rhs.mpVal2; } + + bool operator<(ArithmeticProxy const & rhs) const + { return *mpVal1<*rhs.mpVal1 && *mpVal2<*rhs.mpVal2; } + + bool operator<=(ArithmeticProxy const & rhs) const + { return *mpVal1<=*rhs.mpVal1 && *mpVal2<=*rhs.mpVal2; } + + bool operator>(ArithmeticProxy const & rhs) const + { return *mpVal1>*rhs.mpVal1 && *mpVal2>*rhs.mpVal2; } + + bool operator>=(ArithmeticProxy const & rhs) const + { return *mpVal1>=*rhs.mpVal1 && *mpVal2>=*rhs.mpVal2; } + + int operator-(ArithmeticProxy const & rhs) const + { return *mpVal1 - *rhs.mpVal1; } + + private: + T1* mpVal1; + T2* mpVal2; + }; + + template< typename Iterator1, + typename Iterator2, + typename ValueType, + typename DifferenceType, + typename IteratorCategory, + class Derived > + class CompositeIteratorBase : public NonStandardIterator + { + public: + typedef Iterator1 iterator1_type; + typedef Iterator2 iterator2_type; + typedef ValueType value_type; + typedef DifferenceType difference_type; + typedef IteratorCategory iterator_category; + + struct Impl + { + iterator1_type maIter1; + iterator2_type maIter2; + Impl() + : maIter1() + , maIter2() + { + } + Impl(const iterator1_type& rIter1, const iterator2_type& rIter2) + : maIter1(rIter1) + , maIter2(rIter2) + { + } + }; + + protected: + Impl* pImpl; + + private: + bool equal(CompositeIteratorBase const & rhs) const + { + return (pImpl->maIter1 == rhs.pImpl->maIter1) && (pImpl->maIter2 == rhs.pImpl->maIter2); + } + + public: + CompositeIteratorBase() + { + pImpl = new Impl(); + } + + CompositeIteratorBase(const iterator1_type& rIter1, const iterator2_type& rIter2) + { + pImpl = new Impl(rIter1, rIter2); + } + + CompositeIteratorBase(const CompositeIteratorBase& rOther) + { + pImpl = new Impl(rOther.pImpl->maIter1, rOther.pImpl->maIter2); + } + + ~CompositeIteratorBase() + { + delete pImpl; + } + + bool operator==(Derived const & rhs) const + { + return equal(rhs); + } + + bool operator!=(Derived const & rhs) const + { + return !equal(rhs); + } + + difference_type operator-(Derived const & rhs) const + { + OSL_ASSERT(pImpl->maIter1 - rhs.pImpl->maIter1 == pImpl->maIter2 - rhs.pImpl->maIter2); + return pImpl->maIter1 - rhs.pImpl->maIter1; + } + + Derived & operator+=(difference_type const & s) + { + pImpl->maIter1 += s; + pImpl->maIter2 += s; + return static_cast(*this); + } + + Derived & operator-=(difference_type const & s) + { + pImpl->maIter1 -= s; + pImpl->maIter2 -= s; + return static_cast(*this); + } + + Derived operator+(difference_type const & s) const + { + Derived ret(static_cast(*this)); + ret += s; + return ret; + } + + Derived operator-(difference_type const & s) const + { + Derived ret(static_cast(*this)); + ret -= s; + return ret; + } + + Derived& operator++() + { + ++pImpl->maIter1; + ++pImpl->maIter2; + return static_cast(*this); + } + + Derived& operator--() + { + --pImpl->maIter1; + --pImpl->maIter2; + return static_cast(*this); + } + + Derived operator++(int) + { + Derived ret(static_cast(*this)); + ++pImpl->maIter1; + ++pImpl->maIter2; + return ret; + } + + Derived operator--(int) + { + Derived ret(static_cast(*this)); + --pImpl->maIter1; + --pImpl->maIter2; + return ret; + } + + value_type get() const + { + return value_type(pImpl->maIter1.get(), + pImpl->maIter2.get()); + } + + value_type get(difference_type const & d) const + { + return value_type(pImpl->maIter1.get(d), + pImpl->maIter2.get(d)); + } + + void set( value_type v ) const + { + pImpl->maIter1.set(v); + pImpl->maIter2.set(v); + } + + void set( value_type v, difference_type const & d ) const + { + pImpl->maIter1.set(v,d); + pImpl->maIter2.set(v,d); + } + + CompositeIteratorBase& operator=(const CompositeIteratorBase& rNew) + { + this->pImpl->maIter1 = rNew.pImpl->maIter1; + this->pImpl->maIter2 = rNew.pImpl->maIter2; + return *this; + } + + const iterator1_type& first() const { return pImpl->maIter1; } + iterator1_type& first() { return pImpl->maIter1; } + + const iterator2_type& second() const { return pImpl->maIter2; } + iterator2_type& second() { return pImpl->maIter2; } + }; +} + +/** Provide the composition of two 1D image iterators + + Use this template to compose two iterators into one (e.g. image + and mask). Operations are transitive, e.g. operator== only returns + true, if both wrapped iterator operator== have yielded true. + + Note that both iterators must have compatible difference types. To + avoid funny effects, iterator ranges given by a CompositeIterator + should consist of wrapped iterators of similar range + */ +template< typename Iterator1, + typename Iterator2, + typename ValueType, + typename DifferenceType, + typename IteratorCategory > +class CompositeIterator1D : + public detail::CompositeIteratorBase< Iterator1, + Iterator2, + ValueType, + DifferenceType, + IteratorCategory, + CompositeIterator1D > +{ + typedef detail::CompositeIteratorBase< Iterator1, + Iterator2, + ValueType, + DifferenceType, + IteratorCategory, + CompositeIterator1D > base_type; +public: + CompositeIterator1D() : + base_type() + {} + + CompositeIterator1D( const Iterator1& rIter1, + const Iterator2& rIter2 ) : + base_type( rIter1, rIter2 ) + {} +}; + +/** Provide the composition of two 2D image iterators + + Use this template to compose two iterators into one (e.g. image + and mask). Operations are transitive, e.g. operator== only returns + true, if both wrapped iterator operator== have yielded true. + + Note that both iterators must have compatible difference types. To + avoid funny effects, iterator ranges given by a CompositeIterator + should consist of wrapped iterators of similar range + */ +template< typename Iterator1, typename Iterator2 > class CompositeIterator2D : + public detail::CompositeIteratorBase< Iterator1, + Iterator2, + std::pair< + typename vigra::IteratorTraits::value_type, + typename vigra::IteratorTraits::value_type >, + typename vigra::IteratorTraits::difference_type, + typename vigra::IteratorTraits::iterator_category, + CompositeIterator2D > +{ + typedef detail::CompositeIteratorBase< Iterator1, + Iterator2, + std::pair< + typename vigra::IteratorTraits::value_type, + typename vigra::IteratorTraits::value_type >, + typename vigra::IteratorTraits::difference_type, + typename vigra::IteratorTraits::iterator_category, + CompositeIterator2D > base_type; +public: + typedef CompositeIterator1D< typename Iterator1::row_iterator, + typename Iterator2::row_iterator, + typename base_type::value_type, + int, + typename base_type::iterator_category > row_iterator; + typedef CompositeIterator1D< typename Iterator1::column_iterator, + typename Iterator2::column_iterator, + typename base_type::value_type, + int, + typename base_type::iterator_category > column_iterator; + + typedef detail::ArithmeticProxy< typename Iterator1::MoveX, + typename Iterator2::MoveX > MoveX; + typedef detail::ArithmeticProxy< typename Iterator1::MoveY, + typename Iterator2::MoveY > MoveY; + + MoveX x; + MoveY y; + + CompositeIterator2D() : + base_type(), + x(this->pImpl->maIter1.x,this->pImpl->maIter2.x), + y(this->pImpl->maIter1.y,this->pImpl->maIter2.y) + {} + + CompositeIterator2D( const Iterator1& rIter1, const Iterator2& rIter2 ) : + base_type( rIter1, rIter2 ), + x(this->pImpl->maIter1.x,this->pImpl->maIter2.x), + y(this->pImpl->maIter1.y,this->pImpl->maIter2.y) + {} + + CompositeIterator2D( const CompositeIterator2D& rOld ) : + base_type(rOld), + x(this->pImpl->maIter1.x,this->pImpl->maIter2.x), + y(this->pImpl->maIter1.y,this->pImpl->maIter2.y) + {} + + CompositeIterator2D& operator=( const CompositeIterator2D& rNew ) + { + this->pImpl->maIter1 = rNew.pImpl->maIter1; + this->pImpl->maIter2 = rNew.pImpl->maIter2; + + x = MoveX(this->pImpl->maIter1.x, + this->pImpl->maIter2.x); + y = MoveY(this->pImpl->maIter1.y, + this->pImpl->maIter2.y); + + return *this; + } + + row_iterator rowIterator() const + { + return row_iterator(this->pImpl->maIter1.rowIterator(), + this->pImpl->maIter2.rowIterator()); + } + + column_iterator columnIterator() const + { + return column_iterator(this->pImpl->maIter1.columnIterator(), + this->pImpl->maIter2.columnIterator()); + } +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_COMPOSITEITERATOR_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/endian.hxx b/basebmp/inc/endian.hxx new file mode 100644 index 000000000000..a924f5a71a86 --- /dev/null +++ b/basebmp/inc/endian.hxx @@ -0,0 +1,51 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_ENDIAN_HXX +#define INCLUDED_BASEBMP_INC_ENDIAN_HXX + +#include + +namespace basebmp +{ + +/// Swap the order of bytes for the given POD type +template< typename T > inline T byteSwap( T ); + +#define BASEBMP_BYTE_SWAP(Type,SwapFunc) \ + template<> inline Type byteSwap( Type v ) \ + { \ + return SwapFunc(v); \ + } + +// byteSwap shall fail for any type T not in the list below +BASEBMP_BYTE_SWAP(sal_Int8,) +BASEBMP_BYTE_SWAP(sal_uInt8,) +BASEBMP_BYTE_SWAP(sal_Int16,OSL_SWAPWORD) +BASEBMP_BYTE_SWAP(sal_uInt16,OSL_SWAPWORD) +BASEBMP_BYTE_SWAP(sal_Int32,OSL_SWAPDWORD) +BASEBMP_BYTE_SWAP(sal_uInt32,OSL_SWAPDWORD) + +#undef BASEBMP_BYTE_SWAP + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_ENDIAN_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/fillimage.hxx b/basebmp/inc/fillimage.hxx new file mode 100644 index 000000000000..7acd901edacb --- /dev/null +++ b/basebmp/inc/fillimage.hxx @@ -0,0 +1,63 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_FILLIMAGE_HXX +#define INCLUDED_BASEBMP_INC_FILLIMAGE_HXX + +#include +#include + +namespace basebmp +{ + +template< class DestIterator, class DestAccessor, typename T > +void fillImage( DestIterator begin, + const DestIterator& end, + DestAccessor ad, + const T& fillVal ) +{ + const int width ( end.x - begin.x ); + const int height( end.y - begin.y ); + + for( int y=0; y::row_iterator + rowIter( begin.rowIterator() ); + const typename vigra::IteratorTraits::row_iterator + rowEnd( rowIter + width ); + + // TODO(P2): Provide specialized span fill methods on the + // iterator/accessor + while( rowIter != rowEnd ) + ad.set(fillVal, rowIter++); + } +} + +template< class DestIterator, class DestAccessor, typename T > +inline void fillImage( vigra::triple const& src, + const T& fillVal ) +{ + fillImage(src.first,src.second,src.third,fillVal); +} + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_FILLIMAGE_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/genericcolorimageaccessor.hxx b/basebmp/inc/genericcolorimageaccessor.hxx new file mode 100644 index 000000000000..c8fbe55941cf --- /dev/null +++ b/basebmp/inc/genericcolorimageaccessor.hxx @@ -0,0 +1,76 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_GENERICCOLORIMAGEACCESSOR_HXX +#define INCLUDED_BASEBMP_INC_GENERICCOLORIMAGEACCESSOR_HXX + +#include +#include + +namespace basebmp +{ + /** Access a BitmapDevice generically + + This accessor deals with an opaque BitmapDevice generically, + via getPixel()/setPixel() at the published interface. + */ + class GenericColorImageAccessor + { + BitmapDeviceSharedPtr mpDevice; + DrawMode meDrawMode; + + public: + typedef Color value_type; + + explicit GenericColorImageAccessor( BitmapDeviceSharedPtr const& rTarget ) : + mpDevice(rTarget), + meDrawMode(DrawMode_PAINT) + {} + + GenericColorImageAccessor( BitmapDeviceSharedPtr const& rTarget, + DrawMode eDrawMode ) : + mpDevice(rTarget), + meDrawMode(eDrawMode) + {} + + template< typename Iterator > + Color operator()( Iterator const& i ) const + { return mpDevice->getPixel( basegfx::B2IPoint( i->x,i->y ) ); } + + template< typename Iterator, typename Difference > + Color operator()( Iterator const& i, Difference const& diff) const + { return mpDevice->getPixel( basegfx::B2IPoint( i[diff]->x, + i[diff]->y ) ); } + + template< typename Iterator > + void set(Color const& value, Iterator const& i) const + { return mpDevice->setPixel( basegfx::B2IPoint( i->x,i->y ), + value, meDrawMode ); } + + template< class Iterator, class Difference > + void set(value_type const& value, Iterator const& i, Difference const& diff) const + { return mpDevice->setPixel( basegfx::B2IPoint( i[diff]->x, + i[diff]->y ), + value, meDrawMode ); } + }; +} + +#endif /* INCLUDED_BASEBMP_INC_GENERICCOLORIMAGEACCESSOR_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/greylevelformats.hxx b/basebmp/inc/greylevelformats.hxx new file mode 100644 index 000000000000..a758fa941047 --- /dev/null +++ b/basebmp/inc/greylevelformats.hxx @@ -0,0 +1,129 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_GREYLEVELFORMATS_HXX +#define INCLUDED_BASEBMP_INC_GREYLEVELFORMATS_HXX + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +namespace basebmp +{ + +template< typename PixelType, + typename ColorType, + int UsedRange > struct GreylevelGetter : + public std::unary_function +{ + ColorType operator()( PixelType const& c ) const + { + return ColorTraits::fromGreyscale( + vigra::NumericTraits::toPromote(c) * + vigra::NumericTraits::maxConst / UsedRange ); + } +}; + +template< typename PixelType, + typename ColorType, + int UsedRange > struct GreylevelSetter : + public std::unary_function +{ + PixelType operator()( ColorType const& c ) const + { + return vigra::NumericTraits::toPromote( + ColorTraits::toGreyscale(c)) * + UsedRange / + vigra::NumericTraits::maxConst; + } +}; + + + +template< class Iterator, + class Accessor, + int UsedRange > struct PixelFormatTraitsTemplate_Greylevel +{ + typedef typename Iterator::value_type pixel_type; + + typedef GreylevelGetter getter_type; + typedef GreylevelSetter setter_type; + + typedef Iterator iterator_type; + typedef Accessor raw_accessor_type; + typedef AccessorSelector< + getter_type, + setter_type > accessor_selector; +}; + +template< int BitsPerPixel, + bool MsbFirst > struct PixelFormatTraitsTemplate_PackedGreylevel : + public PixelFormatTraitsTemplate_Greylevel< + PackedPixelIterator< sal_uInt8, + BitsPerPixel, + true >, + NonStandardAccessor< sal_uInt8 >, + (1UL << BitsPerPixel)-1 > +{}; + + + +// 1bpp MSB +typedef PixelFormatTraitsTemplate_PackedGreylevel<1, true> PixelFormatTraits_GREY1_MSB; + +// 1bpp LSB +typedef PixelFormatTraitsTemplate_PackedGreylevel<1, false> PixelFormatTraits_GREY1_LSB; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_GREY1_MSB::getter_type, + PixelFormatTraits_GREY1_MSB::setter_type); + + +// 4bpp MSB +typedef PixelFormatTraitsTemplate_PackedGreylevel<4, true> PixelFormatTraits_GREY4_MSB; + +// 4bpp LSB +typedef PixelFormatTraitsTemplate_PackedGreylevel<4, false> PixelFormatTraits_GREY4_LSB; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_GREY4_MSB::getter_type, + PixelFormatTraits_GREY4_MSB::setter_type); + +// 8bpp +typedef PixelFormatTraitsTemplate_Greylevel< + PixelIterator< sal_uInt8 >, + StandardAccessor< sal_uInt8 >, + 255 > PixelFormatTraits_GREY8; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_GREY8::getter_type, + PixelFormatTraits_GREY8::setter_type); + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_GREYLEVELFORMATS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/iteratortraits.hxx b/basebmp/inc/iteratortraits.hxx new file mode 100644 index 000000000000..a0b65f5e20eb --- /dev/null +++ b/basebmp/inc/iteratortraits.hxx @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_ITERATORTRAITS_HXX +#define INCLUDED_BASEBMP_INC_ITERATORTRAITS_HXX + +#include +#include + +namespace basebmp +{ + +template< class Iterator > struct IteratorTraits +{ + /// VigraTrueType, if iterator does not provide *operator()/operator[] methods + typedef typename vigra::IsDerivedFrom::result + isNonStandardIterator; + + /// Retrieve default accessor for this iterator (and given value type) + template< typename ValueType > struct defaultAccessor : public + // select according to non-standardness of iterator type + vigra::If< isNonStandardIterator, + NonStandardAccessor< ValueType >, + StandardAccessor< ValueType > > + {}; + +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_ITERATORTRAITS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/metafunctions.hxx b/basebmp/inc/metafunctions.hxx new file mode 100644 index 000000000000..16ee2615f4d7 --- /dev/null +++ b/basebmp/inc/metafunctions.hxx @@ -0,0 +1,217 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_METAFUNCTIONS_HXX +#define INCLUDED_BASEBMP_INC_METAFUNCTIONS_HXX + +#include +#include +#include + +#include + +namespace basebmp +{ + +// TODO(Q3): move to generic place (o3tl?) + +/** template meta function: add const qualifier to 2nd type, if given + 1st type has it +*/ +template struct clone_const +{ + typedef B type; +}; +template struct clone_const +{ + typedef const B type; +}; + +/** template meta function: add const qualifier to plain type (if not + already there) + */ +template struct add_const +{ + typedef const T type; +}; +template struct add_const +{ + typedef const T type; +}; + +/// template meta function: remove const qualifier from plain type +template struct remove_const +{ + typedef T type; +}; +template struct remove_const +{ + typedef T type; +}; + + + +/// Base class for an adaptable ternary functor +template< typename A1, typename A2, typename A3, typename R > struct TernaryFunctorBase +{ + typedef A1 first_argument_type; + typedef A2 second_argument_type; + typedef A3 third_argument_type; + typedef R result_type; +}; + + + +/** template meta function: ensure that given integer type is unsigned + + If given integer type is already unsigned, return as-is - + otherwise, convert to unsigned type of same or greater range. + */ +template< typename T > struct make_unsigned; + +#define BASEBMP_MAKE_UNSIGNED(T,U) \ + template<> struct make_unsigned { \ + typedef U type; \ + }; + +BASEBMP_MAKE_UNSIGNED(signed char,unsigned char) +BASEBMP_MAKE_UNSIGNED(unsigned char,unsigned char) +BASEBMP_MAKE_UNSIGNED(short,unsigned short) +BASEBMP_MAKE_UNSIGNED(unsigned short,unsigned short) +BASEBMP_MAKE_UNSIGNED(int,unsigned int) +BASEBMP_MAKE_UNSIGNED(unsigned int,unsigned int) +BASEBMP_MAKE_UNSIGNED(long,unsigned long) +BASEBMP_MAKE_UNSIGNED(unsigned long,unsigned long) + +#undef BASEBMP_MAKE_UNSIGNED + +/// cast integer to unsigned type of similar size +template< typename T > inline typename make_unsigned::type unsigned_cast( T value ) +{ + return static_cast< typename make_unsigned::type >(value); +} + + + +/// returns true, if given number is strictly less than 0 +template< typename T > inline bool is_negative( T x ) +{ + return x < 0; +} + +/// Overload for ints (branch-free) +inline bool is_negative( int x ) +{ + // force logic shift (result for signed shift right is undefined) + return static_cast(x) >> (sizeof(int)*8-1); +} + + + +/// Results in VigraTrueType, if T is of integer type and scalar +template< typename T, typename trueCase, typename falseCase > +struct ifScalarIntegral +{ + typedef + typename vigra::If< + typename vigra::NumericTraits< T >::isIntegral, + typename vigra::If< + typename vigra::NumericTraits< T >::isScalar, + trueCase, + falseCase >::type, + falseCase >::type type; +}; + +/// Results in VigraTrueType, if T is of non-integer type and scalar +template< typename T, typename trueCase, typename falseCase > +struct ifScalarNonIntegral +{ + typedef + typename vigra::If< + typename vigra::NumericTraits< T >::isIntegral, + falseCase, + typename vigra::If< + typename vigra::NumericTraits< T >::isScalar, + trueCase, + falseCase >::type >::type type; +}; + +/// Results in VigraTrueType, if both T1 and T2 are of integer type and scalar +template< typename T1, typename T2, typename trueCase, typename falseCase > +struct ifBothScalarIntegral +{ + typedef + typename ifScalarIntegral< + T1, + typename ifScalarIntegral< + T2, + trueCase, + falseCase >::type, + falseCase >::type type; +}; + + + +/// Count number of trailing zeros +template< unsigned int val > struct numberOfTrailingZeros +{ + enum { next = val >> 1 }; + enum { value = vigra::IfBool< (val & 1) == 0, + numberOfTrailingZeros, + boost::mpl::integral_c< int,-1 > > ::type::value + 1 }; +}; + +template<> struct numberOfTrailingZeros<0> +{ + enum { value = 0 }; +}; + + + +/// Count number of one bits +template< unsigned int val > struct bitcount +{ + enum { next = val >> 1 }; + enum { value = bitcount::value + (val & 1) }; +}; + +template<> struct bitcount<0> +{ + enum { value = 0 }; +}; + + + +/// Shift left for positive shift value, and right otherwise +template< typename T > inline T shiftLeft( T v, int shift ) +{ + return shift > 0 ? v << shift : v >> (-shift); +} + +/// Shift right for positive shift value, and left otherwise +template< typename T > inline T shiftRight( T v, int shift ) +{ + return shift > 0 ? v >> shift : v << (-shift); +} + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_METAFUNCTIONS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/nonstandarditerator.hxx b/basebmp/inc/nonstandarditerator.hxx new file mode 100644 index 000000000000..fbf9683c2af7 --- /dev/null +++ b/basebmp/inc/nonstandarditerator.hxx @@ -0,0 +1,39 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_NONSTANDARDITERATOR_HXX +#define INCLUDED_BASEBMP_INC_NONSTANDARDITERATOR_HXX + +#include + +namespace basebmp +{ + /// Base class defining pointer and reference types as VigraFalseType + struct NonStandardIterator + { + typedef vigra::VigraFalseType reference; + typedef vigra::VigraFalseType index_reference; + typedef vigra::VigraFalseType pointer; + }; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_NONSTANDARDITERATOR_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/packedpixeliterator.hxx b/basebmp/inc/packedpixeliterator.hxx new file mode 100644 index 000000000000..b7bcac09487b --- /dev/null +++ b/basebmp/inc/packedpixeliterator.hxx @@ -0,0 +1,670 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_PACKEDPIXELITERATOR_HXX +#define INCLUDED_BASEBMP_INC_PACKEDPIXELITERATOR_HXX + +#include +#include +#include +#include + +#include +#include + +namespace basebmp +{ + +/// Get bitmask for data at given intra-word position, for given bit depth +template< typename value_type, + int bits_per_pixel, + bool MsbFirst, + typename difference_type > +inline value_type get_mask( difference_type d ) +{ + static_assert(bits_per_pixel > 0, "greater than 0"); + static_assert(sizeof(value_type)*8 % bits_per_pixel == 0, "value_type"); + static_assert(sizeof(value_type)*8 / bits_per_pixel > 1, "value_type"); + static_assert(vigra::TypeTraits::isPOD::asBool, "isPOD"); + + const unsigned int nIntraWordPositions( sizeof(value_type)*8 / bits_per_pixel ); + + // create bits_per_pixel 1s shift to intra-word position + return ((~(~0U << bits_per_pixel)) << bits_per_pixel*(MsbFirst ? + (nIntraWordPositions-1 - (d % nIntraWordPositions)) : + (d % nIntraWordPositions))); +} + +template< int num_intraword_positions, int bits_per_pixel, bool MsbFirst, typename difference_type > inline difference_type get_shift( difference_type remainder ) +{ + return bits_per_pixel*(MsbFirst ? + (num_intraword_positions - 1 - remainder) : + remainder); +} + +template< typename Valuetype, + int bits_per_pixel, + bool MsbFirst > class PackedPixelColumnIterator : public NonStandardIterator +{ +public: + // no reference, no index_reference type here + typedef Valuetype value_type; + typedef int difference_type; + typedef image_traverser_tag iterator_category; + + typedef typename remove_const::type mask_type; + typedef value_type* pointer; + typedef StridedArrayIterator< value_type > MoveY; + + enum { + /** The number of pixel within a single value_type value + */ + num_intraword_positions=sizeof(value_type)*8/bits_per_pixel, + /** Bit mask for one pixel (least significant bits) + */ + bit_mask=~(~0 << bits_per_pixel) + }; + +private: + MoveY y; + mask_type mask_; + difference_type shift_; + + void inc() + { + ++y; + } + + void dec() + { + --y; + } + + bool equal( PackedPixelColumnIterator const & rhs ) const + { + return rhs.y == y; + } + + bool less( PackedPixelColumnIterator const & rhs ) const + { + return y < rhs.y; + } + +public: + PackedPixelColumnIterator() : + y(0), + mask_( get_mask(0) ), + shift_( get_shift(0) ) + {} + + PackedPixelColumnIterator( const MoveY& base, difference_type remainder ) : + y(base), + mask_( get_mask(remainder) ), + shift_( get_shift(remainder) ) + {} + + PackedPixelColumnIterator& operator+=( difference_type d ) + { + y += d; + return *this; + } + + PackedPixelColumnIterator& operator-=( difference_type d ) + { + y -= d; + return *this; + } + + PackedPixelColumnIterator operator+( difference_type d ) + { + PackedPixelColumnIterator res(*this); + res += d; + return res; + } + + PackedPixelColumnIterator operator-( difference_type d ) + { + PackedPixelColumnIterator res(*this); + res -= d; + return res; + } + + PackedPixelColumnIterator& operator++() + { + inc(); + return *this; + } + + PackedPixelColumnIterator& operator--() + { + dec(); + return *this; + } + + PackedPixelColumnIterator operator++(int) + { + PackedPixelColumnIterator res(*this); + inc(); + return res; + } + + PackedPixelColumnIterator operator--(int) + { + PackedPixelColumnIterator res(*this); + dec(); + return res; + } + + bool operator==(PackedPixelColumnIterator const & rhs) const + { + return equal( rhs ); + } + + bool operator!=(PackedPixelColumnIterator const & rhs) const + { + return !equal( rhs ); + } + + bool operator<(PackedPixelColumnIterator const & rhs) const + { + return less(rhs); + } + + bool operator<=(PackedPixelColumnIterator const & rhs) const + { + return !rhs.less(*this); + } + + bool operator>(PackedPixelColumnIterator const & rhs) const + { + return rhs.less(*this); + } + + bool operator>=(PackedPixelColumnIterator const & rhs) const + { + return !less(rhs); + } + + difference_type operator-(PackedPixelColumnIterator const & rhs) const + { + return y - rhs.y; + } + + value_type get() const + { + return unsigned_cast(*y() & mask_) >> shift_; + } + + value_type get(difference_type d) const + { + return unsigned_cast(*y(d) & mask_) >> shift_; + } + + void set( value_type v ) const + { + const value_type pixel_value( (v << shift_) & mask_ ); + *y() = (*y() & ~mask_) | pixel_value; + } + + void set( value_type v, difference_type d ) const + { + const value_type pixel_value( (v << shift_) & mask_ ); + *y(d) = (*y(d) & ~mask_) | pixel_value; + } +}; + +template< typename Valuetype, + int bits_per_pixel, + bool MsbFirst > class PackedPixelRowIterator : public NonStandardIterator +{ +public: + // no reference, no index_reference type here + typedef Valuetype value_type; + typedef int difference_type; + typedef image_traverser_tag iterator_category; + + typedef typename remove_const::type mask_type; + typedef value_type* pointer; + + enum { + /** The number of pixel within a single value_type value + */ + num_intraword_positions=sizeof(value_type)*8/bits_per_pixel, + /** Bit mask for one pixel (least significant bits) + */ + bit_mask=~(~0 << bits_per_pixel) + }; + +private: + pointer data_; + mask_type mask_; + difference_type remainder_; + + void update_mask() + { + mask_ = get_mask(remainder_); + } + + void inc() + { + const difference_type newValue( remainder_ + 1 ); + const difference_type data_offset( newValue / num_intraword_positions ); + + data_ += data_offset; + remainder_ = newValue % num_intraword_positions; + + const mask_type shifted_mask( + MsbFirst ? + unsigned_cast(mask_) >> bits_per_pixel : + mask_ << bits_per_pixel ); + + // data_offset is 0 for shifted mask, and 1 for wrapped-around mask + mask_ = (1-data_offset)*shifted_mask + data_offset*(MsbFirst ? + bit_mask << bits_per_pixel*(num_intraword_positions-1) : + bit_mask); + } + + void dec() + { + const difference_type newValue( remainder_ - 1 ); + const bool isNegative( is_negative(newValue) ); + const difference_type newRemainder( newValue % num_intraword_positions ); + + // calc data_ += newValue / num_intraword_positions; + // remainder_ = newRemainder; + // for newValue >= 0, and + // data_ += newValue / num_intraword_positions - 1; + // remainder_ = num_intraword_positions - newRemainder; + // (to force remainder_ to be positive). + // This is branch-free, if is_negative() is branch-free + const difference_type data_offset( newValue / num_intraword_positions - isNegative ); + data_ += data_offset; + remainder_ = newRemainder + isNegative*num_intraword_positions; + + const mask_type shifted_mask( + MsbFirst ? + mask_ << bits_per_pixel : + unsigned_cast(mask_) >> bits_per_pixel ); + + // data_offset is 0 for shifted mask, and 1 for wrapped-around mask + mask_ = (1-data_offset)*shifted_mask + data_offset*(MsbFirst ? + bit_mask : + bit_mask << bits_per_pixel*(num_intraword_positions-1)); + } + + bool equal( PackedPixelRowIterator const & rhs ) const + { + return rhs.data_ == data_ && rhs.remainder_ == remainder_; + } + + bool less( PackedPixelRowIterator const & rhs ) const + { + return data_ == rhs.data_ ? + (remainder_ < rhs.remainder_) : + (data_ < rhs.data_); + } + +public: + PackedPixelRowIterator() : + data_(0), + mask_( get_mask(0) ), + remainder_(0) + {} + + explicit PackedPixelRowIterator( pointer base, int x ) : + data_(base), + mask_(0), + remainder_(x % num_intraword_positions) + { + update_mask(); + } + + PackedPixelRowIterator& operator+=( difference_type d ) + { + const difference_type newValue( remainder_ + d ); + const bool isNegative( is_negative(newValue) ); + const difference_type newRemainder( newValue % num_intraword_positions ); + + // calc data_ += newValue / num_intraword_positions; + // remainder_ = newRemainder; + // for newValue >= 0, and + // data_ += newValue / num_intraword_positions - 1; + // remainder_ = newRemainder + num_intraword_positions; + // (to force remainder_ to be positive). + // This is branch-free, if is_negative() is branch-free + data_ += newValue / num_intraword_positions - isNegative; + remainder_ = newRemainder + isNegative*num_intraword_positions; + update_mask(); + + return *this; + } + + PackedPixelRowIterator& operator-=( difference_type d ) + { + // forward to operator+= - which has to cope with negative + // values, anyway. + return *this += -d; + } + + PackedPixelRowIterator operator+( difference_type d ) + { + PackedPixelRowIterator res(*this); + res += d; + return res; + } + + PackedPixelRowIterator operator-( difference_type d ) + { + PackedPixelRowIterator res(*this); + res -= d; + return res; + } + + PackedPixelRowIterator& operator++() + { + inc(); + return *this; + } + + PackedPixelRowIterator& operator--() + { + dec(); + return *this; + } + + PackedPixelRowIterator operator++(int) + { + PackedPixelRowIterator res(*this); + inc(); + return res; + } + + PackedPixelRowIterator operator--(int) + { + PackedPixelRowIterator res(*this); + dec(); + return res; + } + + bool operator==(PackedPixelRowIterator const & rhs) const + { + return equal( rhs ); + } + + bool operator!=(PackedPixelRowIterator const & rhs) const + { + return !equal( rhs ); + } + + bool operator<(PackedPixelRowIterator const & rhs) const + { + return less(rhs); + } + + bool operator<=(PackedPixelRowIterator const & rhs) const + { + return !rhs.less(*this); + } + + bool operator>(PackedPixelRowIterator const & rhs) const + { + return rhs.less(*this); + } + + bool operator>=(PackedPixelRowIterator const & rhs) const + { + return !less(rhs); + } + + difference_type operator-(PackedPixelRowIterator const & rhs) const + { + return (data_ - rhs.data_)*num_intraword_positions + (remainder_ - rhs.remainder_); + } + + value_type get() const + { + return unsigned_cast(*data_ & mask_) >> + get_shift(remainder_); + } + + value_type get(difference_type d) const + { + PackedPixelRowIterator tmp(*this); + tmp += d; + return tmp.get(); + } + + void set( value_type v ) const + { + const value_type pixel_value( + (v << + get_shift(remainder_)) + & mask_ ); + *data_ = (*data_ & ~mask_) | pixel_value; + } + + void set( value_type v, difference_type d ) const + { + PackedPixelRowIterator tmp(*this); + tmp += d; + tmp.set(v); + } +}; + +/** 2D image iterator for packed pixel formats + + This iterator can be used for image formats that pack more than + one pixel into an machine data type (like one bit per pixel, eight + of which packed into one char) + */ +template< typename Valuetype, + int bits_per_pixel, + bool MsbFirst > class PackedPixelIterator : public NonStandardIterator +{ +public: + // no reference, no index_reference type here + typedef Valuetype value_type; + typedef vigra::Diff2D difference_type; + typedef image_traverser_tag iterator_category; + typedef PackedPixelRowIterator row_iterator; + typedef PackedPixelColumnIterator column_iterator; + + typedef value_type* pointer; + typedef int MoveX; + typedef StridedArrayIterator< value_type > MoveY; + + enum { + /** The number of pixel within a single value_type value + */ + num_intraword_positions=sizeof(value_type)*8/bits_per_pixel, + /** Bit mask for one pixel (least significant bits) + */ + bit_mask=~(~0 << bits_per_pixel) + }; + + // TODO(F2): direction of iteration (ImageIterator can be made to + // run backwards) + +private: + pointer current() const + { + return y() + (x / num_intraword_positions); + } + + pointer current(int dx, int dy) const + { + return y(dy) + ((x+dx)/num_intraword_positions); + } + + bool equal(PackedPixelIterator const & rhs) const + { + return (x == rhs.x) && (y == rhs.y); + } + +public: + PackedPixelIterator() : + x(0), + y(0) + {} + + PackedPixelIterator(pointer base, int ystride) : + x(0), + y(ystride,base) + {} + + bool operator==(PackedPixelIterator const & rhs) const + { + return equal(rhs); + } + + bool operator!=(PackedPixelIterator const & rhs) const + { + return !equal(rhs); + } + + difference_type operator-(PackedPixelIterator const & rhs) const + { + return difference_type(x - rhs.x, y - rhs.y); + } + + MoveX x; + MoveY y; + + PackedPixelIterator & operator+=(difference_type const & s) + { + x += s.x; + y += s.y; + return *this; + } + + PackedPixelIterator & operator-=(difference_type const & s) + { + x -= s.x; + y -= s.y; + return *this; + } + + PackedPixelIterator operator+(difference_type const & s) const + { + PackedPixelIterator ret(*this); + ret += s; + return ret; + } + + PackedPixelIterator operator-(difference_type const & s) const + { + PackedPixelIterator ret(*this); + ret -= s; + return ret; + } + + row_iterator rowIterator() const + { + return row_iterator(current(),x); + } + + column_iterator columnIterator() const + { + return column_iterator(MoveY(y, + x / num_intraword_positions), + x % num_intraword_positions); + } + + value_type get() const + { + const int remainder( x % num_intraword_positions ); + + return (unsigned_cast(*current() & + get_mask(remainder)) + >> get_shift(remainder)); + } + + value_type get(difference_type const & d) const + { + const int remainder( x(d.x) % num_intraword_positions ); + + return (unsigned_cast(*current(d.x,d.y) & + get_mask(remainder)) + >> get_shift(remainder)); + } + + void set( value_type v ) const + { + const int remainder( x % num_intraword_positions ); + const int mask( get_mask(remainder) ); + const value_type pixel_value( + (v << + get_shift(remainder)) + & mask ); + pointer p = current(); + *p = (*p & ~mask) | pixel_value; + } + + void set( value_type v, difference_type const & d ) const + { + const int remainder( (x + d.x) % num_intraword_positions ); + const int mask( get_mask(remainder) ); + const value_type pixel_value( + (v << + get_shift(remainder)) + & mask ); + pointer p = current(d.x,d.y); + *p = (*p & ~mask) | pixel_value; + } +}; + + + +// partial specialization for the accessor traits masked_accessor +// selector metafunction - can employ fast mask functor for the 1bpp +// case. +template< class Accessor, + class MaskAccessor, + class Iterator, + bool polarity, + bool MsbFirst > struct maskedAccessorSelector< Accessor, + MaskAccessor, + Iterator, + PackedPixelIterator< typename MaskAccessor::value_type, + 1, + MsbFirst >, + polarity > +{ + typedef TernarySetterFunctionAccessorAdapter< + Accessor, + MaskAccessor, + typename outputMaskFunctorSelector< + typename Accessor::value_type, + typename MaskAccessor::value_type, + polarity, + FastMask>::type > + type; +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_PACKEDPIXELITERATOR_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/paletteformats.hxx b/basebmp/inc/paletteformats.hxx new file mode 100644 index 000000000000..f42424cdae44 --- /dev/null +++ b/basebmp/inc/paletteformats.hxx @@ -0,0 +1,139 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_PALETTEFORMATS_HXX +#define INCLUDED_BASEBMP_INC_PALETTEFORMATS_HXX + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace basebmp +{ + + + +/** Lookup index value for given color value in a PaletteImageAccessor + */ +template< class Accessor > struct ColorLookup +{ + typename Accessor::data_type operator()( const Accessor& acc, + typename Accessor::value_type v ) const + { + return acc.lookup(v); + } +}; + + + +// partial specialization of AccessorTraits for PaletteAccessor +template< class Accessor, typename ColorType > struct AccessorTraits< + PaletteImageAccessor< Accessor, ColorType > > +{ + /// value type of described accessor + typedef typename PaletteImageAccessor< Accessor, ColorType >::value_type value_type; + + /// Retrieve stand-alone color lookup function for given Accessor type + typedef ColorLookup< PaletteImageAccessor< Accessor, ColorType > > color_lookup; + + /// Retrieve raw pixel data accessor for given Accessor type + typedef Accessor raw_accessor; + + /** accessor for XOR setter access is disabled, since the results + * are usually completely unintended - you'll usually want to + * wrap an xor_accessor with a PaletteAccessor, not the other way + * around. + */ + typedef vigra::VigraFalseType xor_accessor; + + /** accessor for masked setter access is disabled, since the + * results are usually completely unintended - you'll usually + * want to wrap a masked_accessor with a PaletteAccessor, not the + * other way around. + */ + template< class MaskAccessor, + class Iterator, + class MaskIterator > struct masked_accessor + { + typedef vigra::VigraFalseType type; + }; +}; + + + +template< typename ColorType > struct PaletteAccessorSelector +{ + template< class Accessor > struct wrap_accessor + { + typedef PaletteImageAccessor< Accessor, ColorType > type; + }; +}; + + + +template< class Iterator, + class Accessor > struct PixelFormatTraitsTemplate_Palette +{ + typedef typename Iterator::value_type pixel_type; + typedef Iterator iterator_type; + typedef Accessor raw_accessor_type; + typedef PaletteAccessorSelector accessor_selector; +}; + +template< int BitsPerPixel, + bool MsbFirst > struct PixelFormatTraitsTemplate_PackedPalette : + public PixelFormatTraitsTemplate_Palette< + PackedPixelIterator< sal_uInt8, + BitsPerPixel, + MsbFirst >, + NonStandardAccessor< sal_uInt8 > > +{}; + + + +// 1bpp MSB +typedef PixelFormatTraitsTemplate_PackedPalette<1, true> PixelFormatTraits_PAL1_MSB; + +// 1bpp LSB +typedef PixelFormatTraitsTemplate_PackedPalette<1, false> PixelFormatTraits_PAL1_LSB; + +// 4bpp MSB +typedef PixelFormatTraitsTemplate_PackedPalette<4, true> PixelFormatTraits_PAL4_MSB; + +// 4bpp LSB +typedef PixelFormatTraitsTemplate_PackedPalette<4, false> PixelFormatTraits_PAL4_LSB; + +// 8bpp +typedef PixelFormatTraitsTemplate_Palette< + PixelIterator< sal_uInt8 >, + StandardAccessor< sal_uInt8 > > PixelFormatTraits_PAL8; + +} // namespace basebmp + +#endif // INCLUDED_BASEBMP_INC_PALETTEFORMATS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/paletteimageaccessor.hxx b/basebmp/inc/paletteimageaccessor.hxx new file mode 100644 index 000000000000..85d54885cf69 --- /dev/null +++ b/basebmp/inc/paletteimageaccessor.hxx @@ -0,0 +1,162 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_PALETTEIMAGEACCESSOR_HXX +#define INCLUDED_BASEBMP_INC_PALETTEIMAGEACCESSOR_HXX + +#include +#include + +#include +#include + +#include +#include + +namespace basebmp +{ + +/** Access pixel data via palette indirection + + @tpl Accessor + Raw accessor, to be used to actually access the pixel values + + @tpl ColorType + The color value type to use - e.g. the palette is an array of that + type + */ +template< class Accessor, typename ColorType > class PaletteImageAccessor +{ +public: + typedef typename Accessor::value_type data_type; + typedef ColorType value_type; + +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS +// making all members public, if no member template friends +private: + template friend class PaletteImageAccessor; +#endif + + Accessor maAccessor; + const value_type* mpPalette; + std::size_t mnNumEntries; + +public: + PaletteImageAccessor() : + maAccessor(), + mpPalette(0), + mnNumEntries(0) + {} + + template< class A > explicit + PaletteImageAccessor( PaletteImageAccessor const& rSrc ) : + maAccessor( rSrc.maAccessor ), + mpPalette( rSrc.mpPalette ), + mnNumEntries( rSrc.mnNumEntries ) + {} + + PaletteImageAccessor( const value_type* pPalette, + std::size_t numEntries ) : + maAccessor(), + mpPalette(pPalette), + mnNumEntries(numEntries) + {} + + template< class T > PaletteImageAccessor( T accessor, + const value_type* pPalette, + std::size_t numEntries ) : + maAccessor(accessor), + mpPalette(pPalette), + mnNumEntries(numEntries) + {} + + + + Accessor const& getWrappedAccessor() const { return maAccessor; } + Accessor& getWrappedAccessor() { return maAccessor; } + + + + data_type lookup(value_type const& v) const + { + // TODO(P3): use table-based/octree approach here! + const value_type* best_entry; + const value_type* palette_end( mpPalette+mnNumEntries ); + if( (best_entry=std::find( mpPalette, palette_end, v)) != palette_end ) + return best_entry-mpPalette; + + const value_type* curr_entry( mpPalette ); + best_entry = curr_entry; + while( curr_entry != palette_end ) + { + if( ColorTraits::distance(*curr_entry, + *best_entry) + > ColorTraits::distance(*curr_entry, + v) ) + { + best_entry = curr_entry; + } + + ++curr_entry; + } + + return best_entry-mpPalette; + } + + + + template< class Iterator > + value_type operator()(Iterator const& i) const + { + return mpPalette[ maAccessor(i) ]; + } + + template< class Iterator, class Difference > + value_type operator()(Iterator const& i, Difference const& diff) const + { + return mpPalette[ maAccessor(i,diff) ]; + } + + + + template< typename V, class Iterator > + void set(V const& value, Iterator const& i) const + { + maAccessor.set( + lookup( + vigra::detail::RequiresExplicitCast::cast(value) ), + i ); + } + + template< typename V, class Iterator, class Difference > + void set(V const& value, Iterator const& i, Difference const& diff) const + { + maAccessor.set( + lookup( + vigra::detail::RequiresExplicitCast::cast(value) ), + i, + diff ); + } +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_PALETTEIMAGEACCESSOR_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/pixelformatadapters.hxx b/basebmp/inc/pixelformatadapters.hxx new file mode 100644 index 000000000000..9a6a11d7d8bb --- /dev/null +++ b/basebmp/inc/pixelformatadapters.hxx @@ -0,0 +1,102 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_PIXELFORMATADAPTERS_HXX +#define INCLUDED_BASEBMP_INC_PIXELFORMATADAPTERS_HXX + +#include +#include + +#include + +namespace basebmp +{ + +// convenience functionality, providing everything necessary for a new +// pixel format. simply plug in two conversion functors from/to a +// common color format. + +/** Accessor selection metafunction, used to wrap a given accessor + with one converting between the pixel and color types + + Use the nested template's typedef type, to retrieve an + AccessorAdapter which operates on a pixel value accessor, and + provides color values to the outside. + + Nested like this, to avoid template template parameters at other + places: an instantiated version of AccessorSelector can be passed + to other templates, which in turn can invoke the nested meta + function. + */ +template< typename Getter, + typename Setter > struct AccessorSelector +{ + template< typename Accessor > struct wrap_accessor + { + typedef UnaryFunctionAccessorAdapter< Accessor, + Getter, + Setter > type; + }; +}; + + + +/** Convert color value to pixel data type + */ +template< class Accessor, typename DataType > struct ColorConvert +{ + DataType operator()( const Accessor& acc, + typename Accessor::value_type v ) const + { + return acc.setter(v); + } +}; + + + +/** Macro generates partial specialization for color-conversion + UnaryFunctionAccessorAdapter, and the given getter/setter functors + */ +#define BASEBMP_SPECIALIZE_ACCESSORTRAITS(Getter,Setter) \ +template< class Accessor > struct AccessorTraits< \ + UnaryFunctionAccessorAdapter< Accessor, \ + Getter, \ + Setter > > \ +{ \ + typedef typename Accessor::value_type data_type; \ + typedef UnaryFunctionAccessorAdapter< \ + Accessor, \ + Getter, \ + Setter > accessor_type; \ + typedef typename accessor_type::value_type value_type; \ + typedef ColorConvert< accessor_type, \ + data_type > color_lookup; \ + typedef Accessor raw_accessor; \ + typedef vigra::VigraFalseType xor_accessor; \ + template< class MaskAccessor, \ + class Iterator, \ + class MaskIterator > struct masked_accessor\ + { typedef vigra::VigraFalseType type; }; \ +} + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_PIXELFORMATADAPTERS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/pixeliterator.hxx b/basebmp/inc/pixeliterator.hxx new file mode 100644 index 000000000000..d38af98ca668 --- /dev/null +++ b/basebmp/inc/pixeliterator.hxx @@ -0,0 +1,349 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_PIXELITERATOR_HXX +#define INCLUDED_BASEBMP_INC_PIXELITERATOR_HXX + +#include +#include + +#include +#include + +namespace basebmp +{ + +template< typename Valuetype > class PixelColumnIterator +{ +public: + typedef Valuetype value_type; + typedef Valuetype& reference; + typedef reference index_reference; + typedef Valuetype* pointer; + typedef int difference_type; + typedef image_traverser_tag iterator_category; + + typedef StridedArrayIterator< value_type > MoveY; + +private: + MoveY y; + + bool equal( PixelColumnIterator const & rhs ) const + { + return rhs.y == y; + } + + bool less( PixelColumnIterator const & rhs ) const + { + return y < rhs.y; + } + +public: + PixelColumnIterator() : + y(0) + {} + + explicit PixelColumnIterator( const MoveY& pos ) : + y(pos) + {} + + PixelColumnIterator( const MoveY& pos, int x ) : + y(pos,x) + {} + + PixelColumnIterator& operator+=( difference_type d ) + { + y += d; + return *this; + } + + PixelColumnIterator& operator-=( difference_type d ) + { + y -= d; + return *this; + } + + PixelColumnIterator operator+( difference_type d ) + { + PixelColumnIterator res(*this); + res += d; + return res; + } + + PixelColumnIterator operator-( difference_type d ) + { + PixelColumnIterator res(*this); + res -= d; + return res; + } + + PixelColumnIterator& operator++() + { + ++y; + return *this; + } + + PixelColumnIterator& operator--() + { + --y; + return *this; + } + + PixelColumnIterator operator++(int) + { + PixelColumnIterator res(*this); + ++y; + return res; + } + + PixelColumnIterator operator--(int) + { + PixelColumnIterator res(*this); + --y; + return res; + } + + bool operator==(PixelColumnIterator const & rhs) const + { + return equal( rhs ); + } + + bool operator!=(PixelColumnIterator const & rhs) const + { + return !equal( rhs ); + } + + bool operator<(PixelColumnIterator const & rhs) const + { + return less(rhs); + } + + bool operator<=(PixelColumnIterator const & rhs) const + { + return !rhs.less(*this); + } + + bool operator>(PixelColumnIterator const & rhs) const + { + return rhs.less(*this); + } + + bool operator>=(PixelColumnIterator const & rhs) const + { + return !less(rhs); + } + + difference_type operator-(PixelColumnIterator const & rhs) const + { + return y - rhs.y; + } + + value_type get() const + { + return *y(); + } + + value_type get(difference_type d) const + { + return *y(d); + } + + void set( value_type v ) const + { + *y() = v; + } + + void set( value_type v, difference_type d ) const + { + *y(d) = v; + } + + reference operator*() const + { + return *y(); + } + + pointer operator->() const + { + return y(); + } + + reference operator[](difference_type d) const + { + return *y(d); + } + + reference operator()(int dy) const + { + return *y(dy); + } +}; + +template< typename Valuetype > class PixelIterator +{ +public: + typedef Valuetype value_type; + typedef Valuetype& reference; + typedef reference index_reference; + typedef Valuetype* pointer; + typedef vigra::Diff2D difference_type; + typedef image_traverser_tag iterator_category; + typedef pointer row_iterator; + typedef PixelColumnIterator column_iterator; + + typedef int MoveX; + typedef StridedArrayIterator< value_type > MoveY; + + // TODO(F2): direction of iteration (ImageIterator can be made to + // run backwards) + +private: + bool equal(PixelIterator const & rhs) const + { + return (x == rhs.x) && (y == rhs.y); + } + + pointer current() const + { + return y() + x; + } + + pointer current(int dx, int dy) const + { + return y(dy) + x+dx; + } + +public: + PixelIterator() : + x(0), + y(0) + {} + + PixelIterator(pointer base, int ystride) : + x(0), + y(ystride,base) + {} + + bool operator==(PixelIterator const & rhs) const + { + return equal(rhs); + } + + bool operator!=(PixelIterator const & rhs) const + { + return !equal(rhs); + } + + difference_type operator-(PixelIterator const & rhs) const + { + return difference_type(x - rhs.x, y - rhs.y); + } + + MoveX x; + MoveY y; + + PixelIterator & operator+=(difference_type const & s) + { + x += s.x; + y += s.y; + return *this; + } + + PixelIterator & operator-=(difference_type const & s) + { + x -= s.x; + y -= s.y; + return *this; + } + + PixelIterator operator+(difference_type const & s) const + { + PixelIterator ret(*this); + ret += s; + return ret; + } + + PixelIterator operator-(difference_type const & s) const + { + PixelIterator ret(*this); + ret -= s; + return ret; + } + + row_iterator rowIterator() const + { + return row_iterator(y()+x); + } + + column_iterator columnIterator() const + { + return column_iterator(y,x); + } + + value_type get() const + { + return *current(); + } + + value_type get(difference_type const & d) const + { + return *current(d.y, d.x); + } + + void set( value_type v ) const + { + *current() = v; + } + + void set( value_type v, difference_type const & d ) const + { + *current(d.y,d.x) = v; + } + + reference operator*() const + { + return *current(); + } + + pointer operator->() const + { + return current(); + } + + reference operator[]( const vigra::Diff2D& d ) const + { + return *current(d.x,d.y); + } + + reference operator()(int dx, int dy) const + { + return *current(dx,dy); + } + + pointer operator[](int dy) const + { + return y(dy) + x; + } +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_PIXELITERATOR_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/polypolygonrenderer.hxx b/basebmp/inc/polypolygonrenderer.hxx new file mode 100644 index 000000000000..1c83f32edbce --- /dev/null +++ b/basebmp/inc/polypolygonrenderer.hxx @@ -0,0 +1,360 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_POLYPOLYGONRENDERER_HXX +#define INCLUDED_BASEBMP_INC_POLYPOLYGONRENDERER_HXX + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + + +namespace basebmp +{ + namespace detail + { + /// convert int32 to 32:32 fixed point + inline sal_Int64 toFractional( sal_Int32 v ) { return sal_Int64(sal_uInt64(v) << 32); } + /// convert double to 32:32 fixed point + inline sal_Int64 toFractional( double v ) { return (sal_Int64)(v*SAL_MAX_UINT32 + (v < 0.0 ? -0.5 : 0.5 )); } + /// convert 32:32 fixed point to int32 (truncate) + inline sal_Int32 toInteger( sal_Int64 v ) { return (sal_Int32)(v < 0 ? ~((~v) >> 32) : v >> 32); } + /// convert 32:32 fixed point to int32 (properly rounded) + inline sal_Int32 toRoundedInteger( sal_Int64 v ) { return toInteger(v) + (sal_Int32)((v&0x80000000) >> 31); } + + /** internal vertex store - + + Different from B2DPoint, since we don't need floating + point coords, but orientation of vertex and y counter + */ + struct Vertex + { + sal_Int32 mnYCounter; + sal_Int64 mnX; + sal_Int64 mnXDelta; + + bool mbDownwards; // needed for nonzero winding rule + // fills + + Vertex() : + mnYCounter(0), + mnX(0), + mnXDelta(0), + mbDownwards(true) + {} + Vertex( basegfx::B2DPoint const& rPt1, + basegfx::B2DPoint const& rPt2, + bool bDownwards ) : + mnYCounter( basegfx::fround(rPt2.getY()) - + basegfx::fround(rPt1.getY()) ), + mnX( toFractional( basegfx::fround(rPt1.getX()) )), + mnXDelta( toFractional( + ((rPt2.getX() - rPt1.getX()) / + (double)mnYCounter) )), + mbDownwards(bDownwards) + {} + }; + + typedef std::vector< std::vector > VectorOfVectorOfVertices; + typedef std::vector< Vertex* > VectorOfVertexPtr; + + /// non-templated setup of GET + sal_uInt32 setupGlobalEdgeTable( VectorOfVectorOfVertices& rGET, + basegfx::B2DPolyPolygon const& rPoly, + sal_Int32 nMinY ); + /// sort rAETSrc, copy not-yet-ended edges over to rAETDest + void sortAET( VectorOfVertexPtr& rAETSrc, + VectorOfVertexPtr& rAETDest ); + + /// For the STL algorithms + struct RasterConvertVertexComparator + { + RasterConvertVertexComparator() {} + + bool operator()( const Vertex& rLHS, + const Vertex& rRHS ) const + { + return rLHS.mnX < rRHS.mnX; + } + + bool operator()( const Vertex* pLHS, + const Vertex* pRHS ) const + { + return pLHS->mnX < pRHS->mnX; + } + }; + + } // namespace detail + + + /** Raster-convert a poly-polygon. + + This algorithm does not perform antialiasing, and thus + internally works with integer vertex coordinates. + + @param begin + Left, top edge of the destination bitmap. This position is + considered (0,0) relative to all polygon vertices + + @param ad + Accessor to set pixel values + + @param fillColor + Color to use for filling + + @param rClipRect + Clipping rectangle, relative to the begin iterator. No pixel outside + this clip rect will be modified. + + @param rPoly + Polygon to fill + */ + template< class DestIterator, class DestAccessor, typename T > + void renderClippedPolyPolygon( DestIterator begin, + DestAccessor ad, + T fillColor, + const basegfx::B2IBox& rClipRect, + basegfx::B2DPolyPolygon const& rPoly, + basegfx::FillRule eFillRule ) + { + const sal_Int32 nClipX1( std::max((sal_Int32)0,rClipRect.getMinX()) ); + const sal_Int32 nClipX2( rClipRect.getMaxX() ); + const sal_Int32 nClipY1( std::max((sal_Int32)0,rClipRect.getMinY()) ); + const sal_Int32 nClipY2( rClipRect.getMaxY() ); + const sal_Int64 nClipX1_frac( detail::toFractional(nClipX1) ); + const sal_Int64 nClipX2_frac( detail::toFractional(nClipX2) ); + + basegfx::B2DRange const aPolyBounds( basegfx::tools::getRange(rPoly) ); + + const sal_Int32 nMinY( basegfx::fround(aPolyBounds.getMinY()) ); + const sal_Int32 nMaxY( + std::min( + nClipY2-1, + basegfx::fround(aPolyBounds.getMaxY()))); + + if( nMinY > nMaxY ) + return; // really, nothing to do then. + + detail::VectorOfVectorOfVertices aGET; // the Global Edge Table + aGET.resize( nMaxY - nMinY + 1 ); + + sal_uInt32 const nVertexCount( + detail::setupGlobalEdgeTable( aGET, rPoly, nMinY ) ); + + + // Perform actual scan conversion + + + if( aGET.empty() ) + return; + + detail::VectorOfVertexPtr aAET1; // the Active Edge Table + detail::VectorOfVertexPtr aAET2; + detail::VectorOfVertexPtr* pAET = &aAET1; + detail::VectorOfVertexPtr* pAETOther = &aAET2; + aAET1.reserve( nVertexCount ); + aAET2.reserve( nVertexCount ); + + // current scanline - initially, points to first scanline + // within the clip rect, or to the polygon's first scanline + // (whichever is greater) + DestIterator aScanline( begin + + vigra::Diff2D( + 0, + std::max(nMinY, + nClipY1)) ); + detail::RasterConvertVertexComparator aComp; + + + // now process each of the nMaxY - nMinY + 1 scanlines + + + for( sal_Int32 y=nMinY; y <= nMaxY; ++y ) + { + if( !aGET[y-nMinY].empty() ) + { + // merge AET with current scanline's new vertices (both + // are already correctly sorted) + detail::VectorOfVectorOfVertices::value_type::iterator vertex=aGET[y-nMinY].begin(); + detail::VectorOfVectorOfVertices::value_type::iterator const end=aGET[y-nMinY].end(); + while( vertex != end ) + { + // find insertion pos by binary search, and put ptr + // into active edge vector + pAET->insert( std::lower_bound( pAET->begin(), + pAET->end(), + &(*vertex), + aComp ), + &(*vertex) ); + + ++vertex; + } + } + + // with less than two active edges, no fill visible + if( pAET->size() >= 2 ) + { + typename vigra::IteratorTraits::row_iterator + rowIter( aScanline.rowIterator() ); + + // process each span in current scanline, with + // even-odd fill rule + detail::VectorOfVertexPtr::iterator currVertex( pAET->begin() ); + detail::VectorOfVertexPtr::iterator const lastVertex( pAET->end()-1 ); + sal_uInt32 nCrossedEdges(0); + sal_Int32 nWindingNumber(0); + while( currVertex != lastVertex ) + { + // TODO(P1): might be worth a try to extend the + // size()==2 case also to the actual filling + // here. YMMV. + detail::Vertex& rV1( **currVertex ); + detail::Vertex const& rV2( **++currVertex ); + + nWindingNumber += -1 + 2*int(rV1.mbDownwards); + + // calc fill status for both rules. might save a + // few percent runtime to specialize here... + const bool bEvenOddFill( + eFillRule == basegfx::FillRule_EVEN_ODD && !(nCrossedEdges & 0x01) ); + const bool bNonZeroWindingFill( + eFillRule == basegfx::FillRule_NONZERO_WINDING_NUMBER && nWindingNumber != 0 ); + + // is span visible? + if( (bEvenOddFill || bNonZeroWindingFill) && + y >= nClipY1 && + rV1.mnX < nClipX2_frac && + rV2.mnX > nClipX1_frac ) + { + // clip span to horizontal bounds + sal_Int32 const nStartX( + std::max( nClipX1, + std::min( nClipX2-1, + detail::toRoundedInteger(rV1.mnX) ))); + sal_Int32 const nEndX( + std::max( nClipX1, + std::min( nClipX2, + detail::toRoundedInteger(rV2.mnX) ))); + + typename vigra::IteratorTraits::row_iterator + currPix( rowIter + nStartX); + typename vigra::IteratorTraits::row_iterator + rowEnd( rowIter + nEndX ); + + // TODO(P2): Provide specialized span fill methods on the + // iterator/accessor + while( currPix != rowEnd ) + ad.set(fillColor, currPix++); + } + + // step vertices + rV1.mnX += rV1.mnXDelta; + --rV1.mnYCounter; + + ++nCrossedEdges; + } + + // step vertex also for the last one + detail::Vertex& rLastV( **currVertex ); + rLastV.mnX += rLastV.mnXDelta; + --rLastV.mnYCounter; + + + // prune AET from ended edges, and keep it sorted + + + pAETOther->clear(); + if( pAET->size() == 2 ) + { + // the case of exactly two active edges is both + // sufficiently common (all 'simple' polygons have + // it), and further more would complicate the + // generic case below (which works with a sliding + // triple of vertices). + if( !aComp(*(*pAET)[0], *(*pAET)[1]) ) + std::swap(*(*pAET)[0], *(*pAET)[1]); + + if( (*pAET)[0]->mnYCounter > 0 ) + pAETOther->push_back( (*pAET)[0] ); + if( (*pAET)[1]->mnYCounter > 0 ) + pAETOther->push_back( (*pAET)[1] ); + } + else + { + bool bFallbackTaken(false); + currVertex = pAET->begin(); + detail::VectorOfVertexPtr::iterator prevVertex( currVertex ); + while( currVertex != lastVertex ) + { + // try to get away with one linear swoop and + // simple neighbor swapping. this is an + // overwhelmingly common case - polygons with + // excessively crisscrossing edges (which on + // top of that cross more than one other edge + // per scanline) are seldom. And even if we + // get such a beast here, this extra loop has + // still only linear cost + if( aComp(**(currVertex+1),**currVertex) ) + { + std::swap(*currVertex, *(currVertex+1)); + + if( aComp(**currVertex,**prevVertex) ) + { + // one swap was not sufficient - + // fallback to generic sort algo, then + detail::sortAET(*pAET, *pAETOther); + bFallbackTaken = true; + break; + } + } + + if( (*currVertex)->mnYCounter > 0 ) + pAETOther->push_back( *currVertex ); + + prevVertex = currVertex++; + } + + // don't forget to add last vertex (loop above + // only deals with n-1 vertices) + if( !bFallbackTaken && (*currVertex)->mnYCounter > 0 ) + pAETOther->push_back( *currVertex ); + } + + std::swap( pAET, pAETOther ); + } + + if( y >= nClipY1 ) + ++aScanline.y; + } + } + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_POLYPOLYGONRENDERER_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/rgb24pixelformats.hxx b/basebmp/inc/rgb24pixelformats.hxx new file mode 100644 index 000000000000..6b7edd75a182 --- /dev/null +++ b/basebmp/inc/rgb24pixelformats.hxx @@ -0,0 +1,92 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_RGB24PIXELFORMATS_HXX +#define INCLUDED_BASEBMP_INC_RGB24PIXELFORMATS_HXX + +#include +#include +#include +#include + +#include + +#include + +namespace basebmp +{ + +template< typename PixelType, typename ColorType > struct RGBValueGetter : + public std::unary_function +{ + ColorType operator()( PixelType const& c ) const + { + return ColorType(c.red(),c.green(),c.blue()); + } +}; + +template< typename PixelType, typename ColorType > struct RGBValueSetter : + public std::unary_function +{ + PixelType operator()( ColorType const& c ) const + { + PixelType res; + res.setRed(c.getRed()); + res.setGreen(c.getGreen()); + res.setBlue(c.getBlue()); + return res; + } +}; + + + +template< typename PixelType > struct PixelFormatTraitsTemplate_RGBValue +{ + typedef PixelType pixel_type; + + typedef RGBValueGetter getter_type; + typedef RGBValueSetter setter_type; + + typedef PixelIterator iterator_type; + typedef StandardAccessor raw_accessor_type; + typedef AccessorSelector< + getter_type, setter_type> accessor_selector; +}; + + + +// 24bpp RGB +typedef PixelFormatTraitsTemplate_RGBValue< + vigra::RGBValue > PixelFormatTraits_RGB24; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_RGB24::getter_type, + PixelFormatTraits_RGB24::setter_type); + +// 24bpp BGR +typedef PixelFormatTraitsTemplate_RGBValue< + vigra::RGBValue > PixelFormatTraits_BGR24; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_BGR24::getter_type, + PixelFormatTraits_BGR24::setter_type); + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_RGB24PIXELFORMATS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/rgbmaskpixelformats.hxx b/basebmp/inc/rgbmaskpixelformats.hxx new file mode 100644 index 000000000000..63068826e04f --- /dev/null +++ b/basebmp/inc/rgbmaskpixelformats.hxx @@ -0,0 +1,355 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_RGBMASKPIXELFORMATS_HXX +#define INCLUDED_BASEBMP_INC_RGBMASKPIXELFORMATS_HXX + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +namespace basebmp +{ + +/** Base class operating on RGB truecolor mask pixel + + Use this template, if you have an (integer) pixel type, and three + bitmasks denoting where the channel bits are. + + @tpl PixelType + Input pixel type to operate on + + @tpl ColorType + Underlying color type, to convert the pixel values into + + @tpl RedMask + Bitmask, to access the red bits in the data type + + @tpl GreenMask + Bitmask, to access the green bits in the data type + + @tpl BlueMask + Bitmask, to access the blue bits in the data type + + @tpl SwapBytes + When true, the final pixel values will be byte-swapped before + passed on. + */ +template< typename PixelType, + typename ColorType, + unsigned int RedMask, + unsigned int GreenMask, + unsigned int BlueMask, + bool SwapBytes > struct RGBMaskFunctorBase +{ + typedef PixelType pixel_type; + typedef ColorType color_type; + typedef typename make_unsigned::type unsigned_pixel_type; + typedef typename ColorTraits::component_type component_type; + + // calc corrective shifts for all three channels in advance + enum { + red_shift = numberOfTrailingZeros::value, + green_shift = numberOfTrailingZeros::value, + blue_shift = numberOfTrailingZeros::value, + + red_bits = bitcount::value, + green_bits = bitcount::value, + blue_bits = bitcount::value + }; +}; + +template< typename PixelType, + typename ColorType, + unsigned int RedMask, + unsigned int GreenMask, + unsigned int BlueMask, + bool SwapBytes > struct RGBMaskGetter : + public RGBMaskFunctorBase, + public std::unary_function +{ + typedef RGBMaskFunctorBase base_type; + + ColorType operator()( PixelType v ) const + { + v = SwapBytes ? byteSwap(v) : v; + + const typename base_type::unsigned_pixel_type red (v & RedMask); + const typename base_type::unsigned_pixel_type green(v & GreenMask); + const typename base_type::unsigned_pixel_type blue (v & BlueMask); + + // shift color nibbles to right-aligned position. ORing it + // channel value shifted twice the number of channel bits, to + // spread the value into the component_type range + ColorType res( (shiftRight(red, + base_type::red_shift-8* + static_cast(sizeof(typename base_type::component_type))+ + base_type::red_bits)) | + (shiftRight(red, + base_type::red_shift-8* + static_cast(sizeof(typename base_type::component_type))+ + 2*base_type::red_bits)), + + (shiftRight(green, + base_type::green_shift-8* + static_cast(sizeof(typename base_type::component_type))+ + base_type::green_bits)) | + (shiftRight(green, + base_type::green_shift-8* + static_cast(sizeof(typename base_type::component_type))+ + 2*base_type::green_bits)), + + (shiftRight(blue, + base_type::blue_shift-8* + static_cast(sizeof(typename base_type::component_type))+ + base_type::blue_bits)) | + (shiftRight(blue, + base_type::blue_shift-8* + static_cast(sizeof(typename base_type::component_type))+ + 2*base_type::blue_bits)) ); + return res; + } +}; + +template< typename PixelType, + typename ColorType, + unsigned int BaseValue, + unsigned int RedMask, + unsigned int GreenMask, + unsigned int BlueMask, + bool SwapBytes > struct RGBMaskSetter : + public RGBMaskFunctorBase, + public std::unary_function +{ + typedef RGBMaskFunctorBase base_type; + + PixelType operator()( ColorType const& c ) const + { + const typename base_type::unsigned_pixel_type red (c.getRed()); + const typename base_type::unsigned_pixel_type green(c.getGreen()); + const typename base_type::unsigned_pixel_type blue (c.getBlue()); + + typename base_type::unsigned_pixel_type res( + BaseValue | + (shiftLeft(red, + base_type::red_shift-8* + static_cast(sizeof(typename base_type::component_type))+ + base_type::red_bits) & RedMask) | + (shiftLeft(green, + base_type::green_shift-8* + static_cast(sizeof(typename base_type::component_type))+ + base_type::green_bits) & GreenMask) | + (shiftLeft(blue, + base_type::blue_shift-8* + static_cast(sizeof(typename base_type::component_type))+ + base_type::blue_bits) & BlueMask) ); + + return SwapBytes ? byteSwap(res) : res; + } +}; + + + +template< typename PixelType, + unsigned int BaseValue, + unsigned int RedMask, + unsigned int GreenMask, + unsigned int BlueMask, + bool SwapBytes > struct PixelFormatTraitsTemplate_RGBMask +{ + typedef PixelType pixel_type; + + typedef RGBMaskGetter getter_type; + typedef RGBMaskSetter setter_type; + + typedef PixelIterator iterator_type; + typedef StandardAccessor raw_accessor_type; + typedef AccessorSelector< + getter_type, setter_type> accessor_selector; +}; + + + +// Hopefully this is an understandable plaintext explanation that matches +// reality... + +// BASEBMP_TRUECOLORMASK_LSB_SWAP means that on a big-endian platform, a pixel +// value when viewed as an integer (16 or 32 bits) has to be byte-swapped for +// the channels to match the masks. Or equivalently (I think), on a big-endian +// platform, the masks need to be byte-swapped to be correct. + +// I.e. on a litte-endian platform the masks work as such. + +// BASEBMP_TRUECOLORMASK_MSB_SWAP means the opposite. The masks work as such +// on big-endian platforms, on little-endian platforms the pixel needs to be +// byte-swapped for the masks to work. + +// So in a sense these two names are "backward". It sounds to me as if +// BASEBMP_TRUECOLORMASK_LSB_SWAP would mean "when on LSB, swap" ;) + +#ifdef OSL_LITENDIAN +# define BASEBMP_TRUECOLORMASK_LSB_SWAP false +# define BASEBMP_TRUECOLORMASK_MSB_SWAP true +#else +# ifdef OSL_BIGENDIAN +# define BASEBMP_TRUECOLORMASK_LSB_SWAP true +# define BASEBMP_TRUECOLORMASK_MSB_SWAP false +# else +# error Undetermined endianness! +# endif +#endif + + + +// 16bpp MSB RGB +typedef PixelFormatTraitsTemplate_RGBMask< + sal_uInt16, + 0, + 0xF800, + 0x07E0, + 0x001F, + BASEBMP_TRUECOLORMASK_MSB_SWAP > PixelFormatTraits_RGB16_565_MSB; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_RGB16_565_MSB::getter_type, + PixelFormatTraits_RGB16_565_MSB::setter_type); + +// 16bpp LSB RGB +typedef PixelFormatTraitsTemplate_RGBMask< + sal_uInt16, + 0, + 0xF800, + 0x07E0, + 0x001F, + BASEBMP_TRUECOLORMASK_LSB_SWAP > PixelFormatTraits_RGB16_565_LSB; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_RGB16_565_LSB::getter_type, + PixelFormatTraits_RGB16_565_LSB::setter_type); + + +// 32bpp formats + +// The intent is that the order of channel names in the names of the 32bpp +// format typedefs below correspond to the order of the channel bytes in +// memory, if I understand correctly.... I think the point with the below +// formats is that the channel byte order in memory is the same regardless of +// platform byte order. + +// This one used to be called PixelFormatTraits_RGB32_888. + +typedef PixelFormatTraitsTemplate_RGBMask< + sal_uInt32, + 0xFF000000, + 0x00FF0000, + 0x0000FF00, + 0x000000FF, + BASEBMP_TRUECOLORMASK_LSB_SWAP > PixelFormatTraits_BGRA32_8888; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_BGRA32_8888::getter_type, + PixelFormatTraits_BGRA32_8888::setter_type); + +// This one used to be called PixelFormatTraits_BGR32_888. + +typedef PixelFormatTraitsTemplate_RGBMask< + sal_uInt32, + 0xFF000000, + 0x00FF0000, + 0x0000FF00, + 0x000000FF, + BASEBMP_TRUECOLORMASK_MSB_SWAP > PixelFormatTraits_ARGB32_8888; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_ARGB32_8888::getter_type, + PixelFormatTraits_ARGB32_8888::setter_type); + +// The following two ones were added for Android needs and for completeness + +typedef PixelFormatTraitsTemplate_RGBMask< + sal_uInt32, + 0x000000FF, + 0xFF000000, + 0x00FF0000, + 0x0000FF00, + BASEBMP_TRUECOLORMASK_LSB_SWAP > PixelFormatTraits_ABGR32_8888; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_ABGR32_8888::getter_type, + PixelFormatTraits_ABGR32_8888::setter_type); + +typedef PixelFormatTraitsTemplate_RGBMask< + sal_uInt32, + 0x000000FF, + 0xFF000000, + 0x00FF0000, + 0x0000FF00, + BASEBMP_TRUECOLORMASK_MSB_SWAP > PixelFormatTraits_RGBA32_8888; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_RGBA32_8888::getter_type, + PixelFormatTraits_RGBA32_8888::setter_type); + +// Added for Cairo needs, perhaps Android should get an XRGB and replace +// some uses of ARGB with that instead ? + +typedef PixelFormatTraitsTemplate_RGBMask< + sal_uInt32, + 0x00000000, + 0x00FF0000, + 0x0000FF00, + 0x000000FF, + BASEBMP_TRUECOLORMASK_LSB_SWAP > PixelFormatTraits_BGRX32_8888; +BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_BGRX32_8888::getter_type, + PixelFormatTraits_BGRX32_8888::setter_type); + + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_RGBMASKPIXELFORMATS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/scaleimage.hxx b/basebmp/inc/scaleimage.hxx new file mode 100644 index 000000000000..69beaf696243 --- /dev/null +++ b/basebmp/inc/scaleimage.hxx @@ -0,0 +1,189 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_SCALEIMAGE_HXX +#define INCLUDED_BASEBMP_INC_SCALEIMAGE_HXX + +#include + +#include +#include +#include +#include + +namespace basebmp +{ + +template< class SourceIter, class SourceAcc, + class DestIter, class DestAcc > +void scaleLine( SourceIter s_begin, + SourceIter s_end, + SourceAcc s_acc, + DestIter d_begin, + DestIter d_end, + DestAcc d_acc ) +{ + const int src_width = s_end - s_begin; + const int dest_width = d_end - d_begin; + + OSL_ASSERT( src_width > 0 && dest_width > 0 ); + + if( src_width >= dest_width ) + { + // shrink + int rem = 0; + while( s_begin != s_end ) + { + if( rem >= 0 ) + { + d_acc.set( s_acc(s_begin), d_begin ); + + rem -= src_width; + ++d_begin; + } + + rem += dest_width; + ++s_begin; + } + } + else + { + // enlarge + int rem = -dest_width; + while( d_begin != d_end ) + { + if( rem >= 0 ) + { + rem -= dest_width; + ++s_begin; + } + + d_acc.set( s_acc(s_begin), d_begin ); + + rem += src_width; + ++d_begin; + } + } +} + +/** Scale an image using zero order interpolation (pixel replication) + + Source and destination range must be at least one pixel wide and + high. + + @param s_begin + Start iterator for source image + + @param s_end + End iterator for source image + + @param s_acc + Source accessor + + @param d_begin + Start iterator for destination image + + @param d_end + End iterator for destination image + + @param d_acc + Destination accessor + + @param bMustCopy + When true, scaleImage always copies source, even when doing 1:1 + copy + */ +template< class SourceIter, class SourceAcc, + class DestIter, class DestAcc > +void scaleImage( SourceIter s_begin, + SourceIter s_end, + SourceAcc s_acc, + DestIter d_begin, + DestIter d_end, + DestAcc d_acc, + bool bMustCopy=false ) +{ + const int src_width ( s_end.x - s_begin.x ); + const int src_height( s_end.y - s_begin.y ); + + const int dest_width ( d_end.x - d_begin.x ); + const int dest_height( d_end.y - d_begin.y ); + + if( !bMustCopy && + src_width == dest_width && + src_height == dest_height ) + { + // no scaling involved, can simply copy + vigra::copyImage( s_begin, s_end, s_acc, + d_begin, d_acc ); + return; + } + + typedef vigra::BasicImage TmpImage; + typedef typename TmpImage::traverser TmpImageIter; + + TmpImage tmp_image(src_width, + dest_height); + TmpImageIter t_begin = tmp_image.upperLeft(); + + // scale in y direction + for( int x=0; x +inline void scaleImage( vigra::triple const& src, + vigra::triple const& dst, + bool bMustCopy=false ) +{ + scaleImage(src.first,src.second,src.third, + dst.first,dst.second,dst.third, + bMustCopy); +} + +} + +#endif /* INCLUDED_BASEBMP_INC_SCALEIMAGE_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/stridedarrayiterator.hxx b/basebmp/inc/stridedarrayiterator.hxx new file mode 100644 index 000000000000..821d3aa08414 --- /dev/null +++ b/basebmp/inc/stridedarrayiterator.hxx @@ -0,0 +1,108 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_STRIDEDARRAYITERATOR_HXX +#define INCLUDED_BASEBMP_INC_STRIDEDARRAYITERATOR_HXX + +#include + +namespace basebmp +{ + +/** Like vigra::StridedArrayIterator + + Changed semantics re. DirectionSelector: stride + now counts in raw bytes + + Adapts given ptr, in a way that iterator increments move forward + in strided steps. Stride can, by the way, also be negative + */ +template< typename T > class StridedArrayIterator +{ +public: + typedef typename clone_const::type internal_type; + + /** Create iterator + + @param stride + + Stride in bytes. Given value should better match memory layout + of T, as memory gets reinterpret-casted. + */ + explicit StridedArrayIterator(int stride, T* ptr = 0) : + stride_(stride), + current_(reinterpret_cast(ptr)) + {} + + /** Copy from other StridedArrayIterator, plus given offset + + @param offset + Offset in bytes + */ + StridedArrayIterator( StridedArrayIterator const& rSrc, + int offset ) : + stride_(rSrc.stride_), + current_(reinterpret_cast( + reinterpret_cast(rSrc.current_)+offset)) + {} + + void operator++() {current_ += stride_; } + void operator++(int) {current_ += stride_; } + void operator--() {current_ -= stride_; } + void operator--(int) {current_ -= stride_; } + void operator+=(int dy) {current_ += dy*stride_; } + void operator-=(int dy) {current_ -= dy*stride_; } + + int operator-(StridedArrayIterator const & rhs) const + { return (current_ - rhs.current_) / stride_; } + + bool operator==(StridedArrayIterator const & rhs) const + { return current_ == rhs.current_; } + + bool operator!=(StridedArrayIterator const & rhs) const + { return current_ != rhs.current_; } + + bool operator<(StridedArrayIterator const & rhs) const + { return *this - rhs < 0; } + + bool operator<=(StridedArrayIterator const & rhs) const + { return *this - rhs <= 0; } + + bool operator>(StridedArrayIterator const & rhs) const + { return *this - rhs > 0; } + + bool operator>=(StridedArrayIterator const & rhs) const + { return *this - rhs >= 0; } + + T* operator()() const + { return reinterpret_cast(current_); } + + T* operator()(int d) const + { return reinterpret_cast(current_ + d*stride_); } + +private: + int stride_; + internal_type* current_; +}; + +} // namespace basebmp + +#endif /* INCLUDED_BASEBMP_INC_STRIDEDARRAYITERATOR_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/inc/tools.hxx b/basebmp/inc/tools.hxx new file mode 100644 index 000000000000..c562a305aaed --- /dev/null +++ b/basebmp/inc/tools.hxx @@ -0,0 +1,85 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASEBMP_INC_TOOLS_HXX +#define INCLUDED_BASEBMP_INC_TOOLS_HXX + +#include +#include +#include +#include + +namespace basebmp +{ + inline vigra::Diff2D topLeft( const basegfx::B2IBox& rRange ) + { return vigra::Diff2D(rRange.getMinX(),rRange.getMinY()); } + + inline vigra::Diff2D bottomRight( const basegfx::B2IBox& rRange ) + { return vigra::Diff2D(rRange.getMaxX(),rRange.getMaxY()); } + + template< class Iterator, class Accessor > + inline vigra::triple + destIterRange(Iterator const& begin, + Accessor const& accessor, + const basegfx::B2IBox& rRange) + { + return vigra::triple( + begin + topLeft(rRange), + begin + bottomRight(rRange), + accessor); + } + + template< class Iterator, class Accessor > + inline vigra::triple + srcIterRange(Iterator const& begin, + Accessor const& accessor, + const basegfx::B2IBox& rRange) + { + return vigra::triple( + begin + topLeft(rRange), + begin + bottomRight(rRange), + accessor); + } + + template< class Iterator, class Accessor > + inline vigra::pair + srcIter(Iterator const& begin, + Accessor const& accessor, + const basegfx::B2IPoint& rPt) + { + return vigra::pair( + begin + vigra::Diff2D(rPt.getX(),rPt.getY()), + accessor); + } + + template< class Iterator, class Accessor > + inline vigra::pair + destIter(Iterator const& begin, + Accessor const& accessor, + const basegfx::B2IPoint& rPt) + { + return vigra::pair( + begin + vigra::Diff2D(rPt.getX(),rPt.getY()), + accessor); + } +} + +#endif /* INCLUDED_BASEBMP_INC_TOOLS_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basebmp/source/bitmapdevice.cxx b/basebmp/source/bitmapdevice.cxx index 04d4892ac054..4ef38f05d939 100644 --- a/basebmp/source/bitmapdevice.cxx +++ b/basebmp/source/bitmapdevice.cxx @@ -24,31 +24,31 @@ #include -#include -#include +#include +#include -#include -#include -#include -#include +#include +#include +#include +#include #include -#include -#include +#include +#include -#include -#include -#include -#include +#include +#include +#include +#include #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include -#include +#include #include "intconversion.hxx" #include diff --git a/basebmp/source/polypolygonrenderer.cxx b/basebmp/source/polypolygonrenderer.cxx index 55d6d69a5d98..91cd27340bd0 100644 --- a/basebmp/source/polypolygonrenderer.cxx +++ b/basebmp/source/polypolygonrenderer.cxx @@ -17,7 +17,7 @@ * the License at http://www.apache.org/licenses/LICENSE-2.0 . */ -#include +#include #include diff --git a/include/basebmp/accessor.hxx b/include/basebmp/accessor.hxx deleted file mode 100644 index b77af908a0de..000000000000 --- a/include/basebmp/accessor.hxx +++ /dev/null @@ -1,113 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_ACCESSOR_HXX -#define INCLUDED_BASEBMP_ACCESSOR_HXX - -#include - -namespace basebmp -{ - -/** Standard accessor type - - Accesses the iterator values the standard way (i.e. via - *operator()/operator[]) - */ -template class StandardAccessor -{ -public: - typedef ValueType value_type; - - - - template< class Iterator > - value_type operator()(Iterator const& i) const - { - return *i; - } - - template< class Iterator, class Difference > - value_type operator()(Iterator const& i, Difference const& diff) const - { - return i[diff]; - } - - - - template< typename V, class Iterator > - void set(V const& value, Iterator const& i) const - { - *i = vigra::detail::RequiresExplicitCast::cast(value); - } - - template< typename V, class Iterator, class Difference > - void set(V const& value, Iterator const& i, Difference const& diff) const - { - i[diff] = vigra::detail::RequiresExplicitCast::cast(value); - } -}; - - - -/** Non-standard accessor type - - Uses getter/setter methods at the given iterator type, to access - the underlying values. - */ -template class NonStandardAccessor -{ -public: - typedef ValueType value_type; - - - - template< class Iterator > - value_type operator()(Iterator const& i) const - { - return i.get(); - } - - template< class Iterator, class Difference > - value_type operator()(Iterator const& i, Difference const& diff) const - { - return i.get(diff); - } - - - - template< typename V, class Iterator > - void set(V const& value, Iterator const& i) const - { - i.set( vigra::detail::RequiresExplicitCast::cast(value) ); - } - - template< typename V, class Iterator, class Difference > - void set(V const& value, Iterator const& i, Difference const& diff) const - { - i.set( vigra::detail::RequiresExplicitCast::cast(value), - diff ); - } -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_ACCESSOR_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/accessoradapters.hxx b/include/basebmp/accessoradapters.hxx deleted file mode 100644 index 0d0122e5c7d2..000000000000 --- a/include/basebmp/accessoradapters.hxx +++ /dev/null @@ -1,520 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_ACCESSORADAPTERS_HXX -#define INCLUDED_BASEBMP_ACCESSORADAPTERS_HXX - -#include - -namespace basebmp -{ - -/** Interpose given accessor's set and get methods with two unary - functors. - - @tpl WrappedAccessor - Wrapped type must provide the usual get and set accessor methods, - with the usual signatures (see StandardAccessor for a conforming - example). - - @tpl GetterFunctor - An Adaptable Unary Function (i.e. providing result_type and - argument_type typedefs) - - @tpl SetterFunctor - An Adaptable Unary Function (i.e. providing result_type and - argument_type typedefs) - */ -template< class WrappedAccessor, - typename GetterFunctor, - typename SetterFunctor > class UnaryFunctionAccessorAdapter -{ -public: - typedef typename GetterFunctor::result_type value_type; - typedef typename SetterFunctor::argument_type argument_type; - -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS -// making all members public, if no member template friends -private: - template friend class UnaryFunctionAccessorAdapter; -#endif - - // we don't derive from wrapped type, to avoid ambiguities - // regarding templatized getter/setter methods. - WrappedAccessor maAccessor; - GetterFunctor maGetterFunctor; - SetterFunctor maSetterFunctor; - -public: - UnaryFunctionAccessorAdapter() : - maAccessor(), - maGetterFunctor(), - maSetterFunctor() - {} - - template< class A > explicit - UnaryFunctionAccessorAdapter( UnaryFunctionAccessorAdapter< A, - GetterFunctor, - SetterFunctor > const& rSrc ) : - maAccessor( rSrc.maAccessor ), - maGetterFunctor( rSrc.maGetterFunctor ), - maSetterFunctor( rSrc.maSetterFunctor ) - {} - - template< class T > explicit UnaryFunctionAccessorAdapter( T const& accessor ) : - maAccessor( accessor ), - maGetterFunctor(), - maSetterFunctor() - {} - - template< class T > UnaryFunctionAccessorAdapter( T accessor, - GetterFunctor getterFunctor, - SetterFunctor setterFunctor) : - maAccessor( accessor ), - maGetterFunctor( getterFunctor ), - maSetterFunctor( setterFunctor ) - {} - - - - WrappedAccessor const& getWrappedAccessor() const { return maAccessor; } - WrappedAccessor& getWrappedAccessor() { return maAccessor; } - - - - value_type getter(typename GetterFunctor::argument_type v) const - { - return maGetterFunctor(v); - } - typename SetterFunctor::result_type setter(argument_type v) const - { - return maSetterFunctor(v); - } - - - - template< class Iterator > - value_type operator()(Iterator const& i) const - { - return maGetterFunctor( maAccessor(i) ); - } - - template< class Iterator, class Difference > - value_type operator()(Iterator const& i, Difference const& diff) const - { - return maGetterFunctor( maAccessor(i,diff) ); - } - - - - template< typename V, class Iterator > - void set(V const& value, Iterator const& i) const - { - maAccessor.set( - maSetterFunctor( - vigra::detail::RequiresExplicitCast::cast(value) ), - i ); - } - - template< typename V, class Iterator, class Difference > - void set(V const& value, Iterator const& i, Difference const& diff) const - { - maAccessor.set( - maSetterFunctor( - vigra::detail::RequiresExplicitCast::cast(value) ), - i, - diff ); - } - -}; - - - -/** Interpose given accessor's set methods with a binary function, - taking both old and new value. - - The wrappee's getter methods kept as-is. - - @tpl WrappedAccessor - Wrapped type must provide the usual get and set accessor methods, - with the usual signatures (see StandardAccessor for a conforming - example). Furthermore, must provide a nested typedef value_type. - - @tpl SetterFunctor - An adaptable binary function (i.e. providing nested typedefs for - result_type and first and second argument type) - */ -template< class WrappedAccessor, - typename SetterFunctor > class BinarySetterFunctionAccessorAdapter -{ -public: - typedef typename WrappedAccessor::value_type value_type; - typedef typename SetterFunctor::second_argument_type argument_type; - -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS -// making all members public, if no member template friends -private: - template friend class BinarySetterFunctionAccessorAdapter; -#endif - - WrappedAccessor maAccessor; - SetterFunctor maFunctor; - -public: - BinarySetterFunctionAccessorAdapter() : - maAccessor(), - maFunctor() - {} - - template< class A > explicit - BinarySetterFunctionAccessorAdapter( - BinarySetterFunctionAccessorAdapter< A, - SetterFunctor > const& rSrc ) : - maAccessor( rSrc.maAccessor ), - maFunctor( rSrc.maFunctor ) - {} - - template< class T > explicit BinarySetterFunctionAccessorAdapter( T const& accessor ) : - maAccessor( accessor ), - maFunctor() - {} - - template< class T > BinarySetterFunctionAccessorAdapter( T accessor, - SetterFunctor functor ) : - maAccessor( accessor ), - maFunctor( functor ) - {} - - - - WrappedAccessor const& getWrappedAccessor() const { return maAccessor; } - WrappedAccessor& getWrappedAccessor() { return maAccessor; } - - - - static typename SetterFunctor::result_type setter( - typename SetterFunctor::first_argument_type v1, - argument_type v2 ) - { - return maSetterFunctor(v1,v2); - } - - - - template< class Iterator > - value_type operator()(Iterator const& i) const - { - return maAccessor(i); - } - - template< class Iterator, class Difference > - value_type operator()(Iterator const& i, Difference const& diff) const - { - return maAccessor(i,diff); - } - - - - template< typename V, class Iterator > - void set(V const& value, Iterator const& i) const - { - maAccessor.set( - maFunctor(maAccessor(i), - vigra::detail::RequiresExplicitCast::cast(value)), - i ); - } - - template< typename V, class Iterator, class Difference > - void set(V const& value, Iterator const& i, Difference const& diff) const - { - maAccessor.set( - maFunctor(maAccessor(i,diff), - vigra::detail::RequiresExplicitCast::cast(value)), - i, - diff ); - } - -}; - - - -/** Write through a CompositeIterator's first wrapped iterator, by - piping the first wrapped iterator value, the second iterator - value, and the specified new value through a ternary function. - - Passed iterator must fulfill the CompositeIterator concept. Note - that the getter/setter methods are not templatized regarding the - iterator type, to make the mask calculation optimization below - safe (see the maskedAccessor template metafunction below) - - @tpl WrappedAccessor1 - Wrapped type must provide the usual get and set accessor methods, - with the usual signatures (see StandardAccessor for a conforming - example). Furthermore, the type must provide a nested typedef - value_type (the selection of WrappedAccessor1 as the provider for - that typedef is rather arbitrary. Could have been - WrappedAccessor2, too. So sue me) - - @tpl Functor - An adaptable ternary function (i.e. providing nested typedefs for - result_type and first, second and third argument type) - */ -template< class WrappedAccessor1, - class WrappedAccessor2, - typename Functor > class TernarySetterFunctionAccessorAdapter -{ -public: - typedef typename WrappedAccessor1::value_type value_type; - typedef typename Functor::third_argument_type argument_type; - -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS -// making all members public, if no member template friends -private: - template friend class TernarySetterFunctionAccessorAdapter; -#endif - - WrappedAccessor1 ma1stAccessor; - WrappedAccessor2 ma2ndAccessor; - Functor maFunctor; - -public: - TernarySetterFunctionAccessorAdapter() : - ma1stAccessor(), - ma2ndAccessor(), - maFunctor() - {} - - template< class T > explicit TernarySetterFunctionAccessorAdapter( T const& accessor ) : - ma1stAccessor( accessor ), - ma2ndAccessor(), - maFunctor() - {} - - template< class A1, class A2 > explicit - TernarySetterFunctionAccessorAdapter( - TernarySetterFunctionAccessorAdapter< A1, - A2, - Functor > const& rSrc ) : - ma1stAccessor( rSrc.ma1stAccessor ), - ma2ndAccessor( rSrc.ma2ndAccessor ), - maFunctor( rSrc.maFunctor ) - {} - - template< class T1, class T2 > - TernarySetterFunctionAccessorAdapter( T1 accessor1, - T2 accessor2 ) : - ma1stAccessor( accessor1 ), - ma2ndAccessor( accessor2 ), - maFunctor() - {} - - template< class T1, class T2 > - TernarySetterFunctionAccessorAdapter( T1 accessor1, - T2 accessor2, - Functor func ) : - ma1stAccessor( accessor1 ), - ma2ndAccessor( accessor2 ), - maFunctor( func ) - {} - - - - WrappedAccessor1 const& get1stWrappedAccessor() const { return ma1stAccessor; } - WrappedAccessor1& get1stWrappedAccessor() { return ma1stAccessor; } - - WrappedAccessor2 const& get2ndWrappedAccessor() const { return ma2ndAccessor; } - WrappedAccessor2& get2ndWrappedAccessor() { return ma2ndAccessor; } - - - - static typename Functor::result_type setter( - typename Functor::first_argument_type v1, - typename Functor::second_argument_type v2, - argument_type v3 ) - { - return maSetterFunctor(v1,v2,v3); - } - - - - template< class Iterator > - value_type operator()(Iterator const& i) const - { - return ma1stAccessor(i.first()); - } - - template< class Iterator, class Difference > - value_type operator()(Iterator const& i, Difference const& diff) const - { - return ma1stAccessor(i.second(),diff); - } - - - - template< typename V, class Iterator > - void set(V const& value, Iterator const& i) const - { - ma1stAccessor.set( - maFunctor(ma1stAccessor(i.first()), - ma2ndAccessor(i.second()), - vigra::detail::RequiresExplicitCast::cast(value)), - i.first() ); - } - - template< typename V, class Iterator, class Difference > - void set(V const& value, Iterator const& i, Difference const& diff) const - { - ma1stAccessor.set( - maFunctor(ma1stAccessor(i.first(), diff), - ma2ndAccessor(i.second(),diff), - vigra::detail::RequiresExplicitCast::cast(value)), - i.first(), - diff ); - } - -}; - - - -/** Access two distinct images simultaneously - - Passed iterator must fulfill the CompositeIterator concept - (i.e. wrap the two image's iterators into one - CompositeIterator). The getter and setter methods expect and - return a pair of values, with types equal to the two accessors - value types - - @tpl WrappedAccessor1 - Wrapped type must provide the usual get and set accessor methods, - with the usual signatures (see StandardAccessor for a conforming - example). Furthermore, the type must provide a nested typedef - value_type. - - @tpl WrappedAccessor2 - Wrapped type must provide the usual get and set accessor methods, - with the usual signatures (see StandardAccessor for a conforming - example). Furthermore, the type must provide a nested typedef - value_type. - */ -template< class WrappedAccessor1, - class WrappedAccessor2 > class JoinImageAccessorAdapter -{ -public: - // TODO(F3): Need numeric traits and a few free functions to - // actually calculate with a pair (semantic: apply every operation - // individually to the contained types) - typedef std::pair value_type; - -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS -// making all members public, if no member template friends -private: - template friend class JoinImageAccessorAdapter; -#endif - - WrappedAccessor1 ma1stAccessor; - WrappedAccessor2 ma2ndAccessor; - -public: - JoinImageAccessorAdapter() : - ma1stAccessor(), - ma2ndAccessor() - {} - - template< class T > explicit JoinImageAccessorAdapter( T const& accessor ) : - ma1stAccessor( accessor ), - ma2ndAccessor() - {} - - template< class A1, class A2 > explicit - JoinImageAccessorAdapter( - JoinImageAccessorAdapter< A1, - A2 > const& rSrc ) : - ma1stAccessor( rSrc.ma1stAccessor ), - ma2ndAccessor( rSrc.ma2ndAccessor ) - {} - - template< class T1, class T2 > - JoinImageAccessorAdapter( T1 accessor1, - T2 accessor2 ) : - ma1stAccessor( accessor1 ), - ma2ndAccessor( accessor2 ) - {} - - - - WrappedAccessor1 const& get1stWrappedAccessor() const { return ma1stAccessor; } - WrappedAccessor1& get1stWrappedAccessor() { return ma1stAccessor; } - - WrappedAccessor2 const& get2ndWrappedAccessor() const { return ma2ndAccessor; } - WrappedAccessor2& get2ndWrappedAccessor() { return ma2ndAccessor; } - - - - template< class Iterator > - value_type operator()(Iterator const& i) const - { - return std::make_pair(ma1stAccessor(i.first()), - ma2ndAccessor(i.second())); - } - - template< class Iterator, class Difference > - value_type operator()(Iterator const& i, Difference const& diff) const - { - return std::make_pair(ma1stAccessor(i.first(),diff), - ma2ndAccessor(i.second(),diff)); - } - - - - template< typename V, class Iterator > - void set(V const& value, Iterator const& i) const - { - ma1stAccessor.set( - vigra::detail::RequiresExplicitCast::cast( - value.first), - i.first() ); - ma2ndAccessor.set( - vigra::detail::RequiresExplicitCast::cast( - value.second), - i.second() ); - } - - template< typename V, class Iterator, class Difference > - void set(V const& value, Iterator const& i, Difference const& diff) const - { - ma1stAccessor.set( - vigra::detail::RequiresExplicitCast::cast( - value.first), - i.first(), - diff ); - ma2ndAccessor.set( - vigra::detail::RequiresExplicitCast::cast( - value.second), - i.second(), - diff ); - } - -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_ACCESSORADAPTERS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/accessorfunctors.hxx b/include/basebmp/accessorfunctors.hxx deleted file mode 100644 index 02e3abaded95..000000000000 --- a/include/basebmp/accessorfunctors.hxx +++ /dev/null @@ -1,181 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_ACCESSORFUNCTORS_HXX -#define INCLUDED_BASEBMP_ACCESSORFUNCTORS_HXX - -#include -#include - -#include - -namespace basebmp -{ - -// Some common accessor functors - - - -/// combine two values via XOR -template< typename T > struct XorFunctor : public std::binary_function -{ - T operator()( T v1, T v2 ) const { return v1 ^ v2; } -}; - - - -/// Base class, passing on the arg types -template< typename T, typename M > struct MaskFunctorBase : - public TernaryFunctorBase {}; - - -/** Let a mask flag decide between two values - - @tpl polarity - Mask polarity. When true, a false in the mask denotes - transparency, i.e. the original value will display. And vice - versa. - */ -template< typename T, - typename M, - bool polarity > struct GenericOutputMaskFunctor : public MaskFunctorBase -{ - /// Ternary mask operation - selects v1 for !m == polarity, v2 otherwise - T operator()( T v1, M m, T v2 ) const - { - return !m == polarity ? v1 : v2; - } -}; - -/** Let a mask bit decide between two values (specialization for - integer mask types) - */ -template< typename T, - typename M, - bool polarity > struct IntegerOutputMaskFunctor; -template< typename T, - typename M > struct IntegerOutputMaskFunctor : public MaskFunctorBase -{ - /** Mask v with state of m - - @return v2, if m != 0, v1 otherwise. - */ - T operator()( T v1, M m, T v2 ) const - { - typedef typename make_unsigned::type unsigned_T; - - // mask will be 0, iff m == 0, and 1 otherwise - const T mask( unsigned_cast(m | -m) >> (sizeof(unsigned_T)*8 - 1) ); - return v1*static_cast(1-mask) + v2*mask; - } -}; -template< typename T, - typename M > struct IntegerOutputMaskFunctor : public MaskFunctorBase -{ - /** Mask v with state of m - - @return v2, if m != 0, v1 otherwise. - */ - T operator()( T v1, M m, T v2 ) const - { - typedef typename make_unsigned::type unsigned_T; - - // mask will be 0, iff m == 0, and 1 otherwise - const T mask( unsigned_cast(m | -m) >> (sizeof(unsigned_T)*8 - 1) ); - return v1*mask + v2*static_cast(1-mask); - } -}; - -/** Let a mask bit decide between two values (specialization for - binary-valued mask types) - */ -template< typename T, typename M, bool polarity > struct FastIntegerOutputMaskFunctor; -template< typename T, typename M > struct FastIntegerOutputMaskFunctor : - public MaskFunctorBase -{ - /// Specialization, only valid if mask can only attain 0 or 1 - T operator()( T v1, M m, T v2 ) const - { - OSL_ASSERT(m<=1); - - return v1*static_cast(1-m) + v2*m; - } -}; -template< typename T, typename M > struct FastIntegerOutputMaskFunctor : - public MaskFunctorBase -{ - /// Specialization, only valid if mask can only attain 0 or 1 - T operator()( T v1, M m, T v2 ) const - { - OSL_ASSERT(m<=1); - - return v1*m + v2*static_cast(1-m); - } -}; - - - -/** Split a pair value from a JoinImageAccessorAdapter into its - individual values, and pass it on to a ternary functor - - This wrapper is an adaptable binary functor, and can thus be used - with a BinarySetterFunctionAccessorAdapter. Useful e.g. for - out-of-image alpha channel, or a masked image. - - @tpl Functor - An adaptable ternary functor (as can e.g. be passed to the - TernarySetterFunctionAccessorAdapter) - */ -template< typename Functor > struct BinaryFunctorSplittingWrapper : - public std::binary_function, - typename Functor::result_type> -{ -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS -// making all members public, if no member template friends -private: - template friend struct BinaryFunctorSplittingWrapper; -#endif - Functor maFunctor; - -public: - BinaryFunctorSplittingWrapper() : maFunctor() {} - - template< class A > explicit - BinaryFunctorSplittingWrapper( - BinaryFunctorSplittingWrapper const& src ) : maFunctor(src.maFunctor) {} - - template< class F > explicit - BinaryFunctorSplittingWrapper( F const& func ) : maFunctor(func) {} - - typename Functor::result_type operator()( - typename Functor::first_argument_type v1, - std::pair< typename Functor::third_argument_type, - typename Functor::second_argument_type > const& v2 ) const - { - return maFunctor( v1, v2.second, v2.first ); - } -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_ACCESSORFUNCTORS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/accessortraits.hxx b/include/basebmp/accessortraits.hxx deleted file mode 100644 index eeabae077f6b..000000000000 --- a/include/basebmp/accessortraits.hxx +++ /dev/null @@ -1,126 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_ACCESSORTRAITS_HXX -#define INCLUDED_BASEBMP_ACCESSORTRAITS_HXX - -#include -#include -#include - -#include - -#include - -namespace basebmp -{ - -struct FastMask; -struct NoFastMask; - -/// Metafunction to select output mask functor from iterator and mask value type -template< typename T, typename M, bool polarity, typename DUMMY > struct outputMaskFunctorSelector : public - ifBothScalarIntegral< T, M, - IntegerOutputMaskFunctor< T, M, polarity >, - GenericOutputMaskFunctor< T, M, polarity > > -{ -}; -template< typename T, typename M, bool polarity > struct outputMaskFunctorSelector< T, M, polarity, FastMask > : public - ifBothScalarIntegral< T, M, - FastIntegerOutputMaskFunctor< T, M, polarity >, - GenericOutputMaskFunctor< T, M, polarity > > -{ -}; - -/** Metafunction providing a point of configuration for iterators - capable of employing the fast output mask functor. - - Specialize this metafunction for your case, and pass FastMask to - the outputMaskFunctorSelector. - */ -template< class Accessor, - class MaskAccessor, - class Iterator, - class MaskIterator, - bool polarity > struct maskedAccessorSelector -{ - typedef TernarySetterFunctionAccessorAdapter< - Accessor, - MaskAccessor, - typename outputMaskFunctorSelector< - typename Accessor::value_type, - typename MaskAccessor::value_type, - polarity, - NoFastMask > ::type > - type; -}; - - - -/** Traits template for Accessor - - Provides wrapped types for color lookup, raw pixel access, xor and - mask accessors. - */ -template< class Accessor > struct AccessorTraits -{ - /// value type of described accessor - typedef typename Accessor::value_type value_type; - - /// Retrieve stand-alone color lookup function for given Accessor type - typedef o3tl::project2nd< Accessor, value_type > color_lookup; - - /// Retrieve raw pixel data accessor for given Accessor type - typedef Accessor raw_accessor; - - /// Retrieve wrapped accessor for XOR setter access - typedef BinarySetterFunctionAccessorAdapter< - Accessor, - XorFunctor< value_type > > xor_accessor; - - /** Retrieve masked accessor for given types - - A masked accessor works like a filter, where the mask gates - the accessor's setter methods (if the mask contains a 0 at a - given iterator position, the original value is - preserved. Otherwise, the new value gets set). - - @attention be careful when retrieving a masked accessor for a - set of types, and using it for a different one - there are - partial specializations that take an optimized functor for - certain mask accessors. - */ - template< class MaskAccessor, - class Iterator, - class MaskIterator, - bool polarity > struct masked_accessor : - public maskedAccessorSelector< Accessor, - MaskAccessor, - Iterator, - MaskIterator, - polarity > - {}; - -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_ACCESSORTRAITS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/clippedlinerenderer.hxx b/include/basebmp/clippedlinerenderer.hxx deleted file mode 100644 index 0265a65ee1bb..000000000000 --- a/include/basebmp/clippedlinerenderer.hxx +++ /dev/null @@ -1,438 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_CLIPPEDLINERENDERER_HXX -#define INCLUDED_BASEBMP_CLIPPEDLINERENDERER_HXX - -#include -#include -#include - -#include -#include - -namespace basebmp -{ - -// factored-out bresenham setup code, which is used from two different -// places in renderClippedLine() below. Admittedly messy for the long -// parameter list... -inline bool prepareClip( sal_Int32 a1, - sal_Int32 a2, - sal_Int32 b1, - sal_Int32 da, - sal_Int32 db, - sal_Int32& o_as, - sal_Int32& o_bs, - int sa, - int sb, - sal_Int32& io_rem, - int& o_n, - sal_uInt32 clipCode1, - sal_uInt32 clipCount1, - sal_uInt32 clipCode2, - sal_uInt32 clipCount2, - sal_Int32 aMin, - sal_uInt32 aMinFlag, - sal_Int32 aMax, - sal_uInt32 aMaxFlag, - sal_Int32 bMin, - sal_uInt32 bMinFlag, - sal_Int32 bMax, - sal_uInt32 bMaxFlag, - bool bRoundTowardsPt2, - bool& o_bUseAlternateBresenham ) -{ - int ca(0), cb(0); - if( clipCode1 ) - { - if( clipCode1 & aMinFlag ) - { - ca = 2*db*(aMin - a1); - o_as = aMin; - } - else if( clipCode1 & aMaxFlag ) - { - ca = 2*db*(a1 - aMax); - o_as = aMax; - } - - if( clipCode1 & bMinFlag ) - { - cb = 2*da*(bMin - b1); - o_bs = bMin; - } - else if( clipCode1 & bMaxFlag ) - { - cb = 2*da*(b1 - bMax); - o_bs = bMax; - } - - if( clipCount1 == 2 ) - clipCode1 &= (ca + da < cb + int(!bRoundTowardsPt2)) ? ~(aMinFlag|aMaxFlag) : ~(bMinFlag|bMaxFlag); - - if( clipCode1 & (aMinFlag|aMaxFlag) ) - { - sal_Int32 da2 = 2*da; - - if (da2 == 0) - return false; // overflow - - cb = (ca + da - int(!bRoundTowardsPt2)) / (da2); - - if( sb >= 0 ) - { - o_bs = b1 + cb; - if( o_bs > bMax ) - return false; // fully clipped - } - else - { - o_bs = b1 - cb; - if( o_bs < bMin ) - return false; // fully clipped - } - - io_rem += ca - da2*cb; - } - else - { - sal_Int32 db2 = 2*db; - - if (db2 == 0) - return false; // overflow - - ca = (cb - da + db2 - int(bRoundTowardsPt2)) / (db2); - if( sa >= 0 ) - { - o_as = a1 + ca; - if( o_as > aMax ) - return false; // fully clipped - } - else - { - o_as = a1 - ca; - if( o_as < aMin ) - return false; // fully clipped - } - - io_rem += db2*ca - cb; - } - } - else - { - o_as = a1; o_bs = b1; - } - - if( clipCode2 ) - { - if( clipCount2 == 2 ) - { - ca = 2*db*((clipCode2 & aMinFlag) ? a1 - aMin : aMax - a1); - cb = 2*da*((clipCode2 & bMinFlag) ? b1 - bMin : bMax - b1); - clipCode2 &= (cb + da < ca + int(bRoundTowardsPt2)) ? ~(aMinFlag|aMaxFlag) : ~(bMinFlag|bMaxFlag); - } - - if( clipCode2 & (aMinFlag|aMaxFlag) ) - o_n = (clipCode2 & aMinFlag) ? o_as - aMin : aMax - o_as; - else - { - o_n = (clipCode2 & bMinFlag) ? o_bs - bMin : bMax - o_bs; - o_bUseAlternateBresenham = true; - } - } - else - o_n = (a2 >= o_as) ? a2 - o_as : o_as - a2; - - return true; // at least one pixel to render -} - - -/** Render line to image iterators, clip against given rectangle - - This method renders a line from aPt1 to aPt2, clipped against - rClipRect (the clipping will take place pixel-perfect, i.e. as if - the original bresenham-rendered line would have been clipped each - pixel individually. No slight shifts compared to unclipped lines). - - @param aPt1 - Start point of the line - - @param aPt2 - End point of the line - - @param rClipRect - Rectangle to clip against - - @param color - Color value to render the line with - - @param begin - left-top image iterator - - @param end - right-bottom image iterator - - @param acc - Image accessor - - @param bRoundTowardsPt2 - Rounding mode to use. Giving false here results in line pixel tend - towards pt1, i.e. when a pixel exactly hits the middle between two - pixel, the pixel closer to pt1 will be chosen. Giving true here - makes renderClippedLine() choose pt2 in those cases. - */ -template< class Iterator, class Accessor > -void renderClippedLine( basegfx::B2IPoint aPt1, - basegfx::B2IPoint aPt2, - const basegfx::B2IBox& rClipRect, - typename Accessor::value_type color, - Iterator begin, - Accessor acc, - bool bRoundTowardsPt2=false ) -{ - // Algorithm according to Steven Eker's 'Pixel-perfect line clipping', - // Graphics Gems V, pp. 314-322 - sal_uInt32 clipCode1 = basegfx::tools::getCohenSutherlandClipFlags(aPt1, - rClipRect); - sal_uInt32 clipCode2 = basegfx::tools::getCohenSutherlandClipFlags(aPt2, - rClipRect); - - if( clipCode1 & clipCode2 ) - return; // line fully clipped away, both endpoints share a half-plane - - sal_uInt32 clipCount1 = basegfx::tools::getNumberOfClipPlanes(clipCode1); - sal_uInt32 clipCount2 = basegfx::tools::getNumberOfClipPlanes(clipCode2); - - if( (clipCode1 != 0 && clipCode2 == 0) - || (clipCount1 == 2 && clipCount2 == 1) ) - { - std::swap(clipCount2,clipCount1); - std::swap(clipCode2,clipCode1); - std::swap(aPt1,aPt2); - bRoundTowardsPt2 = !bRoundTowardsPt2; - } - - const sal_Int32 x1 = aPt1.getX(); - const sal_Int32 x2 = aPt2.getX(); - const sal_Int32 y1 = aPt1.getY(); - const sal_Int32 y2 = aPt2.getY(); - - // TODO(E1): This might overflow - sal_Int32 adx = x2 - x1; - int sx = 1; - if( adx < 0 ) - { - adx *= -1; - sx = -1; - } - - // TODO(E1): This might overflow - sal_Int32 ady = y2 - y1; - int sy = 1; - if( ady < 0 ) - { - ady *= -1; - sy = -1; - } - - int n = 0; - sal_Int32 xs = x1; - sal_Int32 ys = y1; - bool bUseAlternateBresenham=false; - - sal_Int32 nMinY(rClipRect.getMinY()); - sal_Int32 nMaxY(rClipRect.getMaxY()-1); - sal_Int32 nMinX(rClipRect.getMinX()); - sal_Int32 nMaxX(rClipRect.getMaxX()-1); - - if( adx >= ady ) - { - // semi-horizontal line - sal_Int32 rem = 2*ady - adx - int(!bRoundTowardsPt2); - - if( !prepareClip(x1, x2, y1, adx, ady, xs, ys, sx, sy, - rem, n, clipCode1, clipCount1, clipCode2, clipCount2, - nMinX, basegfx::tools::RectClipFlags::LEFT, - nMaxX, basegfx::tools::RectClipFlags::RIGHT, - nMinY, basegfx::tools::RectClipFlags::TOP, - nMaxY, basegfx::tools::RectClipFlags::BOTTOM, - bRoundTowardsPt2, bUseAlternateBresenham ) ) - return; // line fully clipped away, no active pixel inside rect - - Iterator currIter( begin + vigra::Diff2D(0,ys) ); - typename vigra::IteratorTraits::row_iterator - rowIter( currIter.rowIterator() + xs ); - - adx *= 2; - ady *= 2; - - if( bUseAlternateBresenham ) - { - if (rem < 0 && ady <= 0) - return; //break will never be hit under these circumstances - - while(true) - { - if (xs >= nMinX && xs <= nMaxX && ys >= nMinY && ys <= nMaxY) - acc.set(color, rowIter); - - if( rem >= 0 ) - { - // this is intended - we clip endpoint against y - // plane, so n here denotes y range to render - if( --n < 0 ) - break; - - ys += sy; - xs += sx; - rem -= adx; - - currIter.y += sy; - rowIter = currIter.rowIterator() + xs; - } - else - { - xs += sx; - rowIter += sx; - } - - rem += ady; - } - } - else - { - while(true) - { - if (xs >= nMinX && xs <= nMaxX && ys >= nMinY && ys <= nMaxY) - acc.set(color, rowIter); - - if( --n < 0 ) - break; - - if( rem >= 0 ) - { - ys += sy; - xs += sx; - rem -= adx; - - currIter.y += sy; - rowIter = currIter.rowIterator() + xs; - } - else - { - xs += sx; - rowIter += sx; - } - - rem += ady; - } - } - } - else - { - // semi-vertical line - sal_Int32 rem = 2*adx - ady - int(!bRoundTowardsPt2); - - if( !prepareClip(y1, y2, x1, ady, adx, ys, xs, sy, sx, - rem, n, clipCode1, clipCount1, clipCode2, clipCount2, - nMinY, basegfx::tools::RectClipFlags::TOP, - nMaxY, basegfx::tools::RectClipFlags::BOTTOM, - nMinX, basegfx::tools::RectClipFlags::LEFT, - nMaxY, basegfx::tools::RectClipFlags::RIGHT, - bRoundTowardsPt2, bUseAlternateBresenham ) ) - return; // line fully clipped away, no active pixel inside rect - - Iterator currIter( begin + vigra::Diff2D(xs,0) ); - typename vigra::IteratorTraits::column_iterator - colIter( currIter.columnIterator() + ys ); - - adx *= 2; - ady *= 2; - - if( bUseAlternateBresenham ) - { - if (rem < 0 && adx <= 0) - return; //break will never be hit under these circumstances - - while(true) - { - if (xs >= nMinX && xs <= nMaxX && ys >= nMinY && ys <= nMaxY) - acc.set(color, colIter); - - if( rem >= 0 ) - { - // this is intended - we clip endpoint against x - // plane, so n here denotes x range to render - if( --n < 0 ) - break; - - xs += sx; - ys += sy; - - rem -= ady; - - currIter.x += sx; - colIter = currIter.columnIterator() + ys; - } - else - { - ys += sy; - colIter += sy; - } - - rem += adx; - } - } - else - { - while(true) - { - if (xs >= nMinX && xs <= nMaxX && ys >= nMinY && ys <= nMaxY) - acc.set(color, colIter); - - if( --n < 0 ) - break; - - if( rem >= 0 ) - { - xs += sx; - ys += sy; - rem -= ady; - - currIter.x += sx; - colIter = currIter.columnIterator() + ys; - } - else - { - ys += sy; - colIter += sy; - } - - rem += adx; - } - } - } -} - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_CLIPPEDLINERENDERER_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/colorblendaccessoradapter.hxx b/include/basebmp/colorblendaccessoradapter.hxx deleted file mode 100644 index 59055b06fe0a..000000000000 --- a/include/basebmp/colorblendaccessoradapter.hxx +++ /dev/null @@ -1,142 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_COLORBLENDACCESSORADAPTER_HXX -#define INCLUDED_BASEBMP_COLORBLENDACCESSORADAPTER_HXX - -#include - -namespace basebmp -{ - -/** Accessor adapter that blends input value against fixed color value - - Used to blend an alpha mask 'through' a fixed color value into the - destination. - - The getter functors return a constant value (usually the zero of - the value type, this preserves the original destination content - when blitting through a mask) - there really isn't no other - sensible default behaviour for these methods. - */ -template< class WrappedAccessor, - typename AlphaType, - bool polarity > class ConstantColorBlendSetterAccessorAdapter -{ -public: - typedef AlphaType alpha_type; - typedef AlphaType value_type; - typedef typename WrappedAccessor::value_type color_type; - -private: - typename ColorTraits< color_type >:: - template blend_functor::type maFunctor; - WrappedAccessor maWrappee; - color_type maBlendColor; - value_type maGetterValue; - -public: - ConstantColorBlendSetterAccessorAdapter() : - maFunctor(), - maWrappee(), - maBlendColor(), - maGetterValue() - {} - - template< class T > explicit ConstantColorBlendSetterAccessorAdapter( T acc ) : - maFunctor(), - maWrappee(acc), - maBlendColor(), - maGetterValue() - {} - - template< class T > ConstantColorBlendSetterAccessorAdapter( T acc, - color_type col ) : - maFunctor(), - maWrappee(acc), - maBlendColor(col), - maGetterValue() - {} - - template< class T > ConstantColorBlendSetterAccessorAdapter( T acc, - color_type col, - value_type val ) : - maFunctor(), - maWrappee(acc), - maBlendColor(col), - maGetterValue(val) - {} - - - - void setColor( color_type col ) { maBlendColor=col; } - color_type getColor() { return maBlendColor; } - void setGetterValue( value_type val ) { maGetterValue=val; } - value_type getGetterValue() { return maGetterValue; } - - - - WrappedAccessor const& getWrappedAccessor() const { return maWrappee; } - WrappedAccessor& getWrappedAccessor() { return maWrappee; } - - - - /// @return constant value, regardless of iterator content - template< typename IteratorType > value_type operator()(SAL_UNUSED_PARAMETER IteratorType const& ) const - { - return maGetterValue; - } - /// @return constant value, regardless of iterator content - template< typename IteratorType, class Difference > - value_type operator()(SAL_UNUSED_PARAMETER IteratorType const& , SAL_UNUSED_PARAMETER Difference const& ) const - { - return maGetterValue; - } - - - - template< typename V, typename IteratorType > - void set(V const& value, IteratorType const& i) const - { - maWrappee.set( - maFunctor( - vigra::detail::RequiresExplicitCast::cast(value), - maWrappee(i), - maBlendColor), - i ); - } - - template< typename V, typename IteratorType, class Difference > - void set(V const& value, IteratorType const& i, Difference const& diff) const - { - maWrappee.set( - maFunctor( - vigra::detail::RequiresExplicitCast::cast(value), - maWrappee(i,diff), - maBlendColor), - i, - diff ); - } -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_COLORBLENDACCESSORADAPTER_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/colormisc.hxx b/include/basebmp/colormisc.hxx deleted file mode 100644 index 233c318e5079..000000000000 --- a/include/basebmp/colormisc.hxx +++ /dev/null @@ -1,185 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_COLORMISC_HXX -#define INCLUDED_BASEBMP_COLORMISC_HXX - -#include -#include -#include -#include -#include - -// Contents of this header moved out of color.hxx, as it is not useful -// for the general public (drags in vigra and other template -// functionality, that shouldn't be necessary for the ordinary client -// of BitmapDevice etc.) - -namespace basebmp -{ - -template< bool polarity > struct ColorBitmaskOutputMaskFunctor; -template<> struct ColorBitmaskOutputMaskFunctor : MaskFunctorBase -{ - Color operator()( Color v1, sal_uInt8 m, Color v2 ) const - { - OSL_ASSERT(m<=1); - - return Color(v1.toInt32()*(sal_uInt8)(1-m) + v2.toInt32()*m); - } -}; -template<> struct ColorBitmaskOutputMaskFunctor : MaskFunctorBase -{ - Color operator()( Color v1, sal_uInt8 m, Color v2 ) const - { - OSL_ASSERT(m<=1); - - return Color(v1.toInt32()*m + v2.toInt32()*(sal_uInt8)(1-m)); - } -}; - -/// Specialized output mask functor for Color value type -template struct outputMaskFunctorSelector< Color, sal_uInt8, polarity, FastMask > -{ - typedef ColorBitmaskOutputMaskFunctor type; -}; - -template< bool polarity > struct ColorBlendFunctor8 - : public TernaryFunctorBase -{ - Color operator()( sal_uInt8 alpha, - Color v1, - Color v2 ) const - { - alpha = polarity ? alpha : 255 - alpha; - - const sal_uInt8 v1_red( v1.getRed() ); - const sal_uInt8 v1_green( v1.getGreen() ); - const sal_uInt8 v1_blue( v1.getBlue() ); - - // using '>> 8' instead of '/ 0x100' is ill-advised (shifted - // value might be negative). Better rely on decent optimizer - // here... - return Color(((((sal_Int32)v2.getRed() - v1_red)*alpha) / 0x100) + v1_red, - ((((sal_Int32)v2.getGreen() - v1_green)*alpha) / 0x100) + v1_green, - ((((sal_Int32)v2.getBlue() - v1_blue)*alpha) / 0x100) + v1_blue); - } -}; - -template< bool polarity > struct ColorBlendFunctor32 - : public TernaryFunctorBase -{ - Color operator()( Color input, - Color v1, - Color v2 ) const - { - sal_uInt8 alpha = input.getGreyscale(); - alpha = polarity ? alpha : 255 - alpha; - - const sal_uInt8 v1_red( v1.getRed() ); - const sal_uInt8 v1_green( v1.getGreen() ); - const sal_uInt8 v1_blue( v1.getBlue() ); - - // using '>> 8' instead of '/ 0x100' is ill-advised (shifted - // value might be negative). Better rely on decent optimizer - // here... - return Color(((((sal_Int32)v2.getRed() - v1_red)*alpha) / 0x100) + v1_red, - ((((sal_Int32)v2.getGreen() - v1_green)*alpha) / 0x100) + v1_green, - ((((sal_Int32)v2.getBlue() - v1_blue)*alpha) / 0x100) + v1_blue); - } -}; - - - -template<> struct ColorTraits< Color > -{ - /// @return number of color channels - static int numChannels() { return 3; } - - /// Type of a color component (i.e. the type of an individual channel) - typedef sal_uInt8 component_type; - - /// Metafunction to select blend functor from color and alpha type - template< typename AlphaType, bool polarity > struct blend_functor; - - /// Calculate normalized distance between color c1 and c2 - static inline double distance( const Color& c1, - const Color& c2 ) - { - return (c1 - c2).magnitude(); - } - - static inline component_type toGreyscale( const Color& c ) - { - return c.getGreyscale(); - } - - static inline Color fromGreyscale( component_type c ) - { - return Color(c,c,c); - } -}; - -/// The version for plain 8 bit alpha -template struct ColorTraits< Color >::blend_functor< sal_uInt8, polarity > -{ - typedef ColorBlendFunctor8 type; -}; - -/// The version taking grey value of a Color -template struct ColorTraits< Color >::blend_functor< Color, polarity > -{ - typedef ColorBlendFunctor32 type; -}; - -} // namespace basebmp - -namespace vigra -{ - -template<> -struct NumericTraits -{ - typedef basebmp::Color Type; - typedef basebmp::Color Promote; - typedef basebmp::Color RealPromote; - typedef std::complex ComplexPromote; - typedef sal_uInt8 ValueType; - - typedef VigraTrueType isIntegral; - typedef VigraFalseType isScalar; - typedef VigraTrueType isSigned; - typedef VigraTrueType isOrdered; - typedef VigraFalseType isComplex; - - static Type zero() { return Type(); } - static Type one() { return Type(0x01010101); } - static Type nonZero() { return Type(0x01010101); } - - static Promote toPromote(const Type& v) { return v; } - static RealPromote toRealPromote(const Type& v) { return v; } - static Type fromPromote(const Promote& v) { return v; } - static Type fromRealPromote(const RealPromote& v) { return v; } -}; - -} // namespace vigra - -#endif /* INCLUDED_BASEBMP_COLORMISC_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/colortraits.hxx b/include/basebmp/colortraits.hxx deleted file mode 100644 index 0b0c4921f234..000000000000 --- a/include/basebmp/colortraits.hxx +++ /dev/null @@ -1,144 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_COLORTRAITS_HXX -#define INCLUDED_BASEBMP_COLORTRAITS_HXX - -#include -#include - -#include - -namespace basebmp -{ - -/** Functor template, to calculate alpha blending between two - values. Float case. - - @tpl polarity - When true, 0 means fully transparent, and 1 fully opaque. And vice - versa. - */ -template< typename ValueType, - typename AlphaType, - bool polarity > struct BlendFunctor; -template< typename ValueType, - typename AlphaType > struct BlendFunctor - : public TernaryFunctorBase -{ - ValueType operator()( AlphaType alpha, - ValueType v1, - ValueType v2 ) const - { - const typename vigra::NumericTraits::RealPromote fAlpha( - vigra::NumericTraits::toRealPromote(alpha)); - return (vigra::NumericTraits::one()-fAlpha)*v1 + fAlpha*v2; - } -}; -template< typename ValueType, - typename AlphaType > struct BlendFunctor - : public TernaryFunctorBase -{ - ValueType operator()( AlphaType alpha, - ValueType v1, - ValueType v2 ) const - { - const typename vigra::NumericTraits::RealPromote fAlpha( - vigra::NumericTraits::toRealPromote(alpha)); - return fAlpha*v1 + (vigra::NumericTraits::one()-fAlpha)*v2; - } -}; - -/** Functor template, to calculate alpha blending between two - values. Integer case. - - @tpl polarity - When true, 0 means fully transparent, and 1 fully opaque. And vice - versa. - */ -template< typename ValueType, - typename AlphaType, - bool polarity > struct IntegerBlendFunctor; -template< typename ValueType, - typename AlphaType > struct IntegerBlendFunctor - : public TernaryFunctorBase -{ - ValueType operator()( AlphaType alpha, - ValueType v1, - ValueType v2 ) const - { - return (vigra::NumericTraits::toPromote( - vigra::NumericTraits::max()-alpha)*v1 + alpha*v2) / - vigra::NumericTraits::max(); - } -}; -template< typename ValueType, - typename AlphaType > struct IntegerBlendFunctor - : public TernaryFunctorBase -{ - ValueType operator()( AlphaType alpha, - ValueType v1, - ValueType v2 ) const - { - return (alpha*v1 + - vigra::NumericTraits::toPromote( - vigra::NumericTraits::max()-alpha)*v2) / - vigra::NumericTraits::max(); - } -}; - - - -template< typename ColorType > struct ColorTraits -{ - /// Metafunction to select blend functor from color and alpha type - template< typename AlphaType, bool polarity > struct blend_functor : public - ifScalarIntegral< AlphaType, - IntegerBlendFunctor< ColorType, AlphaType, polarity >, - BlendFunctor< ColorType, AlphaType, polarity > > {}; - - /// @return number of color channels - static int numChannels() { return 1; } - - /// Type of a color component (i.e. the type of an individual channel) - typedef ColorType component_type; - - /// Calculate normalized distance between color c1 and c2 - static inline vigra::NormTraits distance( ColorType c1, - ColorType c2 ) - { - return vigra::norm(c1 - c2); - } - - static inline component_type toGreyscale( ColorType c ) - { - return c; - } - - static inline ColorType fromGreyscale( component_type c ) - { - return c; - } -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_COLORTRAITS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/compositeiterator.hxx b/include/basebmp/compositeiterator.hxx deleted file mode 100644 index 182318160483..000000000000 --- a/include/basebmp/compositeiterator.hxx +++ /dev/null @@ -1,395 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_COMPOSITEITERATOR_HXX -#define INCLUDED_BASEBMP_COMPOSITEITERATOR_HXX - -#include -#include - -#include -#include -#include - - -namespace basebmp -{ - -namespace detail -{ - template< typename T1, typename T2 > class ArithmeticProxy - { - public: - ArithmeticProxy(T1& val1, T2& val2) : - mpVal1( &val1 ), - mpVal2( &val2 ) - {} - - void operator++() { ++(*mpVal1); ++(*mpVal2); } - void operator++(int) { (*mpVal1)++; (*mpVal2)++; } - void operator--() { --(*mpVal1); --(*mpVal2); } - void operator--(int) { (*mpVal1)--; (*mpVal2)--; } - void operator+=(int d) {*mpVal1+=d; *mpVal2+=d; } - void operator-=(int d) {*mpVal1-=d; *mpVal2-=d; } - - bool operator==(ArithmeticProxy const & rhs) const - { return *mpVal1==*rhs.mpVal1 && *mpVal2==*rhs.mpVal2; } - - bool operator!=(ArithmeticProxy const & rhs) const - { return *mpVal1!=*rhs.mpVal1 || *mpVal2!=*rhs.mpVal2; } - - bool operator<(ArithmeticProxy const & rhs) const - { return *mpVal1<*rhs.mpVal1 && *mpVal2<*rhs.mpVal2; } - - bool operator<=(ArithmeticProxy const & rhs) const - { return *mpVal1<=*rhs.mpVal1 && *mpVal2<=*rhs.mpVal2; } - - bool operator>(ArithmeticProxy const & rhs) const - { return *mpVal1>*rhs.mpVal1 && *mpVal2>*rhs.mpVal2; } - - bool operator>=(ArithmeticProxy const & rhs) const - { return *mpVal1>=*rhs.mpVal1 && *mpVal2>=*rhs.mpVal2; } - - int operator-(ArithmeticProxy const & rhs) const - { return *mpVal1 - *rhs.mpVal1; } - - private: - T1* mpVal1; - T2* mpVal2; - }; - - template< typename Iterator1, - typename Iterator2, - typename ValueType, - typename DifferenceType, - typename IteratorCategory, - class Derived > - class CompositeIteratorBase : public NonStandardIterator - { - public: - typedef Iterator1 iterator1_type; - typedef Iterator2 iterator2_type; - typedef ValueType value_type; - typedef DifferenceType difference_type; - typedef IteratorCategory iterator_category; - - struct Impl - { - iterator1_type maIter1; - iterator2_type maIter2; - Impl() - : maIter1() - , maIter2() - { - } - Impl(const iterator1_type& rIter1, const iterator2_type& rIter2) - : maIter1(rIter1) - , maIter2(rIter2) - { - } - }; - - protected: - Impl* pImpl; - - private: - bool equal(CompositeIteratorBase const & rhs) const - { - return (pImpl->maIter1 == rhs.pImpl->maIter1) && (pImpl->maIter2 == rhs.pImpl->maIter2); - } - - public: - CompositeIteratorBase() - { - pImpl = new Impl(); - } - - CompositeIteratorBase(const iterator1_type& rIter1, const iterator2_type& rIter2) - { - pImpl = new Impl(rIter1, rIter2); - } - - CompositeIteratorBase(const CompositeIteratorBase& rOther) - { - pImpl = new Impl(rOther.pImpl->maIter1, rOther.pImpl->maIter2); - } - - ~CompositeIteratorBase() - { - delete pImpl; - } - - bool operator==(Derived const & rhs) const - { - return equal(rhs); - } - - bool operator!=(Derived const & rhs) const - { - return !equal(rhs); - } - - difference_type operator-(Derived const & rhs) const - { - OSL_ASSERT(pImpl->maIter1 - rhs.pImpl->maIter1 == pImpl->maIter2 - rhs.pImpl->maIter2); - return pImpl->maIter1 - rhs.pImpl->maIter1; - } - - Derived & operator+=(difference_type const & s) - { - pImpl->maIter1 += s; - pImpl->maIter2 += s; - return static_cast(*this); - } - - Derived & operator-=(difference_type const & s) - { - pImpl->maIter1 -= s; - pImpl->maIter2 -= s; - return static_cast(*this); - } - - Derived operator+(difference_type const & s) const - { - Derived ret(static_cast(*this)); - ret += s; - return ret; - } - - Derived operator-(difference_type const & s) const - { - Derived ret(static_cast(*this)); - ret -= s; - return ret; - } - - Derived& operator++() - { - ++pImpl->maIter1; - ++pImpl->maIter2; - return static_cast(*this); - } - - Derived& operator--() - { - --pImpl->maIter1; - --pImpl->maIter2; - return static_cast(*this); - } - - Derived operator++(int) - { - Derived ret(static_cast(*this)); - ++pImpl->maIter1; - ++pImpl->maIter2; - return ret; - } - - Derived operator--(int) - { - Derived ret(static_cast(*this)); - --pImpl->maIter1; - --pImpl->maIter2; - return ret; - } - - value_type get() const - { - return value_type(pImpl->maIter1.get(), - pImpl->maIter2.get()); - } - - value_type get(difference_type const & d) const - { - return value_type(pImpl->maIter1.get(d), - pImpl->maIter2.get(d)); - } - - void set( value_type v ) const - { - pImpl->maIter1.set(v); - pImpl->maIter2.set(v); - } - - void set( value_type v, difference_type const & d ) const - { - pImpl->maIter1.set(v,d); - pImpl->maIter2.set(v,d); - } - - CompositeIteratorBase& operator=(const CompositeIteratorBase& rNew) - { - this->pImpl->maIter1 = rNew.pImpl->maIter1; - this->pImpl->maIter2 = rNew.pImpl->maIter2; - return *this; - } - - const iterator1_type& first() const { return pImpl->maIter1; } - iterator1_type& first() { return pImpl->maIter1; } - - const iterator2_type& second() const { return pImpl->maIter2; } - iterator2_type& second() { return pImpl->maIter2; } - }; -} - -/** Provide the composition of two 1D image iterators - - Use this template to compose two iterators into one (e.g. image - and mask). Operations are transitive, e.g. operator== only returns - true, if both wrapped iterator operator== have yielded true. - - Note that both iterators must have compatible difference types. To - avoid funny effects, iterator ranges given by a CompositeIterator - should consist of wrapped iterators of similar range - */ -template< typename Iterator1, - typename Iterator2, - typename ValueType, - typename DifferenceType, - typename IteratorCategory > -class CompositeIterator1D : - public detail::CompositeIteratorBase< Iterator1, - Iterator2, - ValueType, - DifferenceType, - IteratorCategory, - CompositeIterator1D > -{ - typedef detail::CompositeIteratorBase< Iterator1, - Iterator2, - ValueType, - DifferenceType, - IteratorCategory, - CompositeIterator1D > base_type; -public: - CompositeIterator1D() : - base_type() - {} - - CompositeIterator1D( const Iterator1& rIter1, - const Iterator2& rIter2 ) : - base_type( rIter1, rIter2 ) - {} -}; - -/** Provide the composition of two 2D image iterators - - Use this template to compose two iterators into one (e.g. image - and mask). Operations are transitive, e.g. operator== only returns - true, if both wrapped iterator operator== have yielded true. - - Note that both iterators must have compatible difference types. To - avoid funny effects, iterator ranges given by a CompositeIterator - should consist of wrapped iterators of similar range - */ -template< typename Iterator1, typename Iterator2 > class CompositeIterator2D : - public detail::CompositeIteratorBase< Iterator1, - Iterator2, - std::pair< - typename vigra::IteratorTraits::value_type, - typename vigra::IteratorTraits::value_type >, - typename vigra::IteratorTraits::difference_type, - typename vigra::IteratorTraits::iterator_category, - CompositeIterator2D > -{ - typedef detail::CompositeIteratorBase< Iterator1, - Iterator2, - std::pair< - typename vigra::IteratorTraits::value_type, - typename vigra::IteratorTraits::value_type >, - typename vigra::IteratorTraits::difference_type, - typename vigra::IteratorTraits::iterator_category, - CompositeIterator2D > base_type; -public: - typedef CompositeIterator1D< typename Iterator1::row_iterator, - typename Iterator2::row_iterator, - typename base_type::value_type, - int, - typename base_type::iterator_category > row_iterator; - typedef CompositeIterator1D< typename Iterator1::column_iterator, - typename Iterator2::column_iterator, - typename base_type::value_type, - int, - typename base_type::iterator_category > column_iterator; - - typedef detail::ArithmeticProxy< typename Iterator1::MoveX, - typename Iterator2::MoveX > MoveX; - typedef detail::ArithmeticProxy< typename Iterator1::MoveY, - typename Iterator2::MoveY > MoveY; - - MoveX x; - MoveY y; - - CompositeIterator2D() : - base_type(), - x(this->pImpl->maIter1.x,this->pImpl->maIter2.x), - y(this->pImpl->maIter1.y,this->pImpl->maIter2.y) - {} - - CompositeIterator2D( const Iterator1& rIter1, const Iterator2& rIter2 ) : - base_type( rIter1, rIter2 ), - x(this->pImpl->maIter1.x,this->pImpl->maIter2.x), - y(this->pImpl->maIter1.y,this->pImpl->maIter2.y) - {} - - CompositeIterator2D( const CompositeIterator2D& rOld ) : - base_type(rOld), - x(this->pImpl->maIter1.x,this->pImpl->maIter2.x), - y(this->pImpl->maIter1.y,this->pImpl->maIter2.y) - {} - - CompositeIterator2D& operator=( const CompositeIterator2D& rNew ) - { - this->pImpl->maIter1 = rNew.pImpl->maIter1; - this->pImpl->maIter2 = rNew.pImpl->maIter2; - - x = MoveX(this->pImpl->maIter1.x, - this->pImpl->maIter2.x); - y = MoveY(this->pImpl->maIter1.y, - this->pImpl->maIter2.y); - - return *this; - } - - row_iterator rowIterator() const - { - return row_iterator(this->pImpl->maIter1.rowIterator(), - this->pImpl->maIter2.rowIterator()); - } - - column_iterator columnIterator() const - { - return column_iterator(this->pImpl->maIter1.columnIterator(), - this->pImpl->maIter2.columnIterator()); - } -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_COMPOSITEITERATOR_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/endian.hxx b/include/basebmp/endian.hxx deleted file mode 100644 index 22c32b6077ac..000000000000 --- a/include/basebmp/endian.hxx +++ /dev/null @@ -1,51 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_ENDIAN_HXX -#define INCLUDED_BASEBMP_ENDIAN_HXX - -#include - -namespace basebmp -{ - -/// Swap the order of bytes for the given POD type -template< typename T > inline T byteSwap( T ); - -#define BASEBMP_BYTE_SWAP(Type,SwapFunc) \ - template<> inline Type byteSwap( Type v ) \ - { \ - return SwapFunc(v); \ - } - -// byteSwap shall fail for any type T not in the list below -BASEBMP_BYTE_SWAP(sal_Int8,) -BASEBMP_BYTE_SWAP(sal_uInt8,) -BASEBMP_BYTE_SWAP(sal_Int16,OSL_SWAPWORD) -BASEBMP_BYTE_SWAP(sal_uInt16,OSL_SWAPWORD) -BASEBMP_BYTE_SWAP(sal_Int32,OSL_SWAPDWORD) -BASEBMP_BYTE_SWAP(sal_uInt32,OSL_SWAPDWORD) - -#undef BASEBMP_BYTE_SWAP - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_ENDIAN_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/fillimage.hxx b/include/basebmp/fillimage.hxx deleted file mode 100644 index 561b02906c0f..000000000000 --- a/include/basebmp/fillimage.hxx +++ /dev/null @@ -1,63 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_FILLIMAGE_HXX -#define INCLUDED_BASEBMP_FILLIMAGE_HXX - -#include -#include - -namespace basebmp -{ - -template< class DestIterator, class DestAccessor, typename T > -void fillImage( DestIterator begin, - const DestIterator& end, - DestAccessor ad, - const T& fillVal ) -{ - const int width ( end.x - begin.x ); - const int height( end.y - begin.y ); - - for( int y=0; y::row_iterator - rowIter( begin.rowIterator() ); - const typename vigra::IteratorTraits::row_iterator - rowEnd( rowIter + width ); - - // TODO(P2): Provide specialized span fill methods on the - // iterator/accessor - while( rowIter != rowEnd ) - ad.set(fillVal, rowIter++); - } -} - -template< class DestIterator, class DestAccessor, typename T > -inline void fillImage( vigra::triple const& src, - const T& fillVal ) -{ - fillImage(src.first,src.second,src.third,fillVal); -} - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_FILLIMAGE_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/genericcolorimageaccessor.hxx b/include/basebmp/genericcolorimageaccessor.hxx deleted file mode 100644 index 5aaa95327176..000000000000 --- a/include/basebmp/genericcolorimageaccessor.hxx +++ /dev/null @@ -1,76 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_GENERICCOLORIMAGEACCESSOR_HXX -#define INCLUDED_BASEBMP_GENERICCOLORIMAGEACCESSOR_HXX - -#include -#include - -namespace basebmp -{ - /** Access a BitmapDevice generically - - This accessor deals with an opaque BitmapDevice generically, - via getPixel()/setPixel() at the published interface. - */ - class GenericColorImageAccessor - { - BitmapDeviceSharedPtr mpDevice; - DrawMode meDrawMode; - - public: - typedef Color value_type; - - explicit GenericColorImageAccessor( BitmapDeviceSharedPtr const& rTarget ) : - mpDevice(rTarget), - meDrawMode(DrawMode_PAINT) - {} - - GenericColorImageAccessor( BitmapDeviceSharedPtr const& rTarget, - DrawMode eDrawMode ) : - mpDevice(rTarget), - meDrawMode(eDrawMode) - {} - - template< typename Iterator > - Color operator()( Iterator const& i ) const - { return mpDevice->getPixel( basegfx::B2IPoint( i->x,i->y ) ); } - - template< typename Iterator, typename Difference > - Color operator()( Iterator const& i, Difference const& diff) const - { return mpDevice->getPixel( basegfx::B2IPoint( i[diff]->x, - i[diff]->y ) ); } - - template< typename Iterator > - void set(Color const& value, Iterator const& i) const - { return mpDevice->setPixel( basegfx::B2IPoint( i->x,i->y ), - value, meDrawMode ); } - - template< class Iterator, class Difference > - void set(value_type const& value, Iterator const& i, Difference const& diff) const - { return mpDevice->setPixel( basegfx::B2IPoint( i[diff]->x, - i[diff]->y ), - value, meDrawMode ); } - }; -} - -#endif /* INCLUDED_BASEBMP_GENERICCOLORIMAGEACCESSOR_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/greylevelformats.hxx b/include/basebmp/greylevelformats.hxx deleted file mode 100644 index 705c26d7d506..000000000000 --- a/include/basebmp/greylevelformats.hxx +++ /dev/null @@ -1,129 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_GREYLEVELFORMATS_HXX -#define INCLUDED_BASEBMP_GREYLEVELFORMATS_HXX - -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include - -namespace basebmp -{ - -template< typename PixelType, - typename ColorType, - int UsedRange > struct GreylevelGetter : - public std::unary_function -{ - ColorType operator()( PixelType const& c ) const - { - return ColorTraits::fromGreyscale( - vigra::NumericTraits::toPromote(c) * - vigra::NumericTraits::maxConst / UsedRange ); - } -}; - -template< typename PixelType, - typename ColorType, - int UsedRange > struct GreylevelSetter : - public std::unary_function -{ - PixelType operator()( ColorType const& c ) const - { - return vigra::NumericTraits::toPromote( - ColorTraits::toGreyscale(c)) * - UsedRange / - vigra::NumericTraits::maxConst; - } -}; - - - -template< class Iterator, - class Accessor, - int UsedRange > struct PixelFormatTraitsTemplate_Greylevel -{ - typedef typename Iterator::value_type pixel_type; - - typedef GreylevelGetter getter_type; - typedef GreylevelSetter setter_type; - - typedef Iterator iterator_type; - typedef Accessor raw_accessor_type; - typedef AccessorSelector< - getter_type, - setter_type > accessor_selector; -}; - -template< int BitsPerPixel, - bool MsbFirst > struct PixelFormatTraitsTemplate_PackedGreylevel : - public PixelFormatTraitsTemplate_Greylevel< - PackedPixelIterator< sal_uInt8, - BitsPerPixel, - true >, - NonStandardAccessor< sal_uInt8 >, - (1UL << BitsPerPixel)-1 > -{}; - - - -// 1bpp MSB -typedef PixelFormatTraitsTemplate_PackedGreylevel<1, true> PixelFormatTraits_GREY1_MSB; - -// 1bpp LSB -typedef PixelFormatTraitsTemplate_PackedGreylevel<1, false> PixelFormatTraits_GREY1_LSB; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_GREY1_MSB::getter_type, - PixelFormatTraits_GREY1_MSB::setter_type); - - -// 4bpp MSB -typedef PixelFormatTraitsTemplate_PackedGreylevel<4, true> PixelFormatTraits_GREY4_MSB; - -// 4bpp LSB -typedef PixelFormatTraitsTemplate_PackedGreylevel<4, false> PixelFormatTraits_GREY4_LSB; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_GREY4_MSB::getter_type, - PixelFormatTraits_GREY4_MSB::setter_type); - -// 8bpp -typedef PixelFormatTraitsTemplate_Greylevel< - PixelIterator< sal_uInt8 >, - StandardAccessor< sal_uInt8 >, - 255 > PixelFormatTraits_GREY8; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_GREY8::getter_type, - PixelFormatTraits_GREY8::setter_type); - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_GREYLEVELFORMATS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/iteratortraits.hxx b/include/basebmp/iteratortraits.hxx deleted file mode 100644 index 5d87df7d5a85..000000000000 --- a/include/basebmp/iteratortraits.hxx +++ /dev/null @@ -1,49 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_ITERATORTRAITS_HXX -#define INCLUDED_BASEBMP_ITERATORTRAITS_HXX - -#include -#include - -namespace basebmp -{ - -template< class Iterator > struct IteratorTraits -{ - /// VigraTrueType, if iterator does not provide *operator()/operator[] methods - typedef typename vigra::IsDerivedFrom::result - isNonStandardIterator; - - /// Retrieve default accessor for this iterator (and given value type) - template< typename ValueType > struct defaultAccessor : public - // select according to non-standardness of iterator type - vigra::If< isNonStandardIterator, - NonStandardAccessor< ValueType >, - StandardAccessor< ValueType > > - {}; - -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_ITERATORTRAITS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/metafunctions.hxx b/include/basebmp/metafunctions.hxx deleted file mode 100644 index 1f3f1806042a..000000000000 --- a/include/basebmp/metafunctions.hxx +++ /dev/null @@ -1,217 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_METAFUNCTIONS_HXX -#define INCLUDED_BASEBMP_METAFUNCTIONS_HXX - -#include -#include -#include - -#include - -namespace basebmp -{ - -// TODO(Q3): move to generic place (o3tl?) - -/** template meta function: add const qualifier to 2nd type, if given - 1st type has it -*/ -template struct clone_const -{ - typedef B type; -}; -template struct clone_const -{ - typedef const B type; -}; - -/** template meta function: add const qualifier to plain type (if not - already there) - */ -template struct add_const -{ - typedef const T type; -}; -template struct add_const -{ - typedef const T type; -}; - -/// template meta function: remove const qualifier from plain type -template struct remove_const -{ - typedef T type; -}; -template struct remove_const -{ - typedef T type; -}; - - - -/// Base class for an adaptable ternary functor -template< typename A1, typename A2, typename A3, typename R > struct TernaryFunctorBase -{ - typedef A1 first_argument_type; - typedef A2 second_argument_type; - typedef A3 third_argument_type; - typedef R result_type; -}; - - - -/** template meta function: ensure that given integer type is unsigned - - If given integer type is already unsigned, return as-is - - otherwise, convert to unsigned type of same or greater range. - */ -template< typename T > struct make_unsigned; - -#define BASEBMP_MAKE_UNSIGNED(T,U) \ - template<> struct make_unsigned { \ - typedef U type; \ - }; - -BASEBMP_MAKE_UNSIGNED(signed char,unsigned char) -BASEBMP_MAKE_UNSIGNED(unsigned char,unsigned char) -BASEBMP_MAKE_UNSIGNED(short,unsigned short) -BASEBMP_MAKE_UNSIGNED(unsigned short,unsigned short) -BASEBMP_MAKE_UNSIGNED(int,unsigned int) -BASEBMP_MAKE_UNSIGNED(unsigned int,unsigned int) -BASEBMP_MAKE_UNSIGNED(long,unsigned long) -BASEBMP_MAKE_UNSIGNED(unsigned long,unsigned long) - -#undef BASEBMP_MAKE_UNSIGNED - -/// cast integer to unsigned type of similar size -template< typename T > inline typename make_unsigned::type unsigned_cast( T value ) -{ - return static_cast< typename make_unsigned::type >(value); -} - - - -/// returns true, if given number is strictly less than 0 -template< typename T > inline bool is_negative( T x ) -{ - return x < 0; -} - -/// Overload for ints (branch-free) -inline bool is_negative( int x ) -{ - // force logic shift (result for signed shift right is undefined) - return static_cast(x) >> (sizeof(int)*8-1); -} - - - -/// Results in VigraTrueType, if T is of integer type and scalar -template< typename T, typename trueCase, typename falseCase > -struct ifScalarIntegral -{ - typedef - typename vigra::If< - typename vigra::NumericTraits< T >::isIntegral, - typename vigra::If< - typename vigra::NumericTraits< T >::isScalar, - trueCase, - falseCase >::type, - falseCase >::type type; -}; - -/// Results in VigraTrueType, if T is of non-integer type and scalar -template< typename T, typename trueCase, typename falseCase > -struct ifScalarNonIntegral -{ - typedef - typename vigra::If< - typename vigra::NumericTraits< T >::isIntegral, - falseCase, - typename vigra::If< - typename vigra::NumericTraits< T >::isScalar, - trueCase, - falseCase >::type >::type type; -}; - -/// Results in VigraTrueType, if both T1 and T2 are of integer type and scalar -template< typename T1, typename T2, typename trueCase, typename falseCase > -struct ifBothScalarIntegral -{ - typedef - typename ifScalarIntegral< - T1, - typename ifScalarIntegral< - T2, - trueCase, - falseCase >::type, - falseCase >::type type; -}; - - - -/// Count number of trailing zeros -template< unsigned int val > struct numberOfTrailingZeros -{ - enum { next = val >> 1 }; - enum { value = vigra::IfBool< (val & 1) == 0, - numberOfTrailingZeros, - boost::mpl::integral_c< int,-1 > > ::type::value + 1 }; -}; - -template<> struct numberOfTrailingZeros<0> -{ - enum { value = 0 }; -}; - - - -/// Count number of one bits -template< unsigned int val > struct bitcount -{ - enum { next = val >> 1 }; - enum { value = bitcount::value + (val & 1) }; -}; - -template<> struct bitcount<0> -{ - enum { value = 0 }; -}; - - - -/// Shift left for positive shift value, and right otherwise -template< typename T > inline T shiftLeft( T v, int shift ) -{ - return shift > 0 ? v << shift : v >> (-shift); -} - -/// Shift right for positive shift value, and left otherwise -template< typename T > inline T shiftRight( T v, int shift ) -{ - return shift > 0 ? v >> shift : v << (-shift); -} - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_METAFUNCTIONS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/nonstandarditerator.hxx b/include/basebmp/nonstandarditerator.hxx deleted file mode 100644 index ff51c59afcee..000000000000 --- a/include/basebmp/nonstandarditerator.hxx +++ /dev/null @@ -1,39 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_NONSTANDARDITERATOR_HXX -#define INCLUDED_BASEBMP_NONSTANDARDITERATOR_HXX - -#include - -namespace basebmp -{ - /// Base class defining pointer and reference types as VigraFalseType - struct NonStandardIterator - { - typedef vigra::VigraFalseType reference; - typedef vigra::VigraFalseType index_reference; - typedef vigra::VigraFalseType pointer; - }; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_NONSTANDARDITERATOR_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/packedpixeliterator.hxx b/include/basebmp/packedpixeliterator.hxx deleted file mode 100644 index a536cec01012..000000000000 --- a/include/basebmp/packedpixeliterator.hxx +++ /dev/null @@ -1,670 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_PACKEDPIXELITERATOR_HXX -#define INCLUDED_BASEBMP_PACKEDPIXELITERATOR_HXX - -#include -#include -#include -#include - -#include -#include - -namespace basebmp -{ - -/// Get bitmask for data at given intra-word position, for given bit depth -template< typename value_type, - int bits_per_pixel, - bool MsbFirst, - typename difference_type > -inline value_type get_mask( difference_type d ) -{ - static_assert(bits_per_pixel > 0, "greater than 0"); - static_assert(sizeof(value_type)*8 % bits_per_pixel == 0, "value_type"); - static_assert(sizeof(value_type)*8 / bits_per_pixel > 1, "value_type"); - static_assert(vigra::TypeTraits::isPOD::asBool, "isPOD"); - - const unsigned int nIntraWordPositions( sizeof(value_type)*8 / bits_per_pixel ); - - // create bits_per_pixel 1s shift to intra-word position - return ((~(~0U << bits_per_pixel)) << bits_per_pixel*(MsbFirst ? - (nIntraWordPositions-1 - (d % nIntraWordPositions)) : - (d % nIntraWordPositions))); -} - -template< int num_intraword_positions, int bits_per_pixel, bool MsbFirst, typename difference_type > inline difference_type get_shift( difference_type remainder ) -{ - return bits_per_pixel*(MsbFirst ? - (num_intraword_positions - 1 - remainder) : - remainder); -} - -template< typename Valuetype, - int bits_per_pixel, - bool MsbFirst > class PackedPixelColumnIterator : public NonStandardIterator -{ -public: - // no reference, no index_reference type here - typedef Valuetype value_type; - typedef int difference_type; - typedef image_traverser_tag iterator_category; - - typedef typename remove_const::type mask_type; - typedef value_type* pointer; - typedef StridedArrayIterator< value_type > MoveY; - - enum { - /** The number of pixel within a single value_type value - */ - num_intraword_positions=sizeof(value_type)*8/bits_per_pixel, - /** Bit mask for one pixel (least significant bits) - */ - bit_mask=~(~0 << bits_per_pixel) - }; - -private: - MoveY y; - mask_type mask_; - difference_type shift_; - - void inc() - { - ++y; - } - - void dec() - { - --y; - } - - bool equal( PackedPixelColumnIterator const & rhs ) const - { - return rhs.y == y; - } - - bool less( PackedPixelColumnIterator const & rhs ) const - { - return y < rhs.y; - } - -public: - PackedPixelColumnIterator() : - y(0), - mask_( get_mask(0) ), - shift_( get_shift(0) ) - {} - - PackedPixelColumnIterator( const MoveY& base, difference_type remainder ) : - y(base), - mask_( get_mask(remainder) ), - shift_( get_shift(remainder) ) - {} - - PackedPixelColumnIterator& operator+=( difference_type d ) - { - y += d; - return *this; - } - - PackedPixelColumnIterator& operator-=( difference_type d ) - { - y -= d; - return *this; - } - - PackedPixelColumnIterator operator+( difference_type d ) - { - PackedPixelColumnIterator res(*this); - res += d; - return res; - } - - PackedPixelColumnIterator operator-( difference_type d ) - { - PackedPixelColumnIterator res(*this); - res -= d; - return res; - } - - PackedPixelColumnIterator& operator++() - { - inc(); - return *this; - } - - PackedPixelColumnIterator& operator--() - { - dec(); - return *this; - } - - PackedPixelColumnIterator operator++(int) - { - PackedPixelColumnIterator res(*this); - inc(); - return res; - } - - PackedPixelColumnIterator operator--(int) - { - PackedPixelColumnIterator res(*this); - dec(); - return res; - } - - bool operator==(PackedPixelColumnIterator const & rhs) const - { - return equal( rhs ); - } - - bool operator!=(PackedPixelColumnIterator const & rhs) const - { - return !equal( rhs ); - } - - bool operator<(PackedPixelColumnIterator const & rhs) const - { - return less(rhs); - } - - bool operator<=(PackedPixelColumnIterator const & rhs) const - { - return !rhs.less(*this); - } - - bool operator>(PackedPixelColumnIterator const & rhs) const - { - return rhs.less(*this); - } - - bool operator>=(PackedPixelColumnIterator const & rhs) const - { - return !less(rhs); - } - - difference_type operator-(PackedPixelColumnIterator const & rhs) const - { - return y - rhs.y; - } - - value_type get() const - { - return unsigned_cast(*y() & mask_) >> shift_; - } - - value_type get(difference_type d) const - { - return unsigned_cast(*y(d) & mask_) >> shift_; - } - - void set( value_type v ) const - { - const value_type pixel_value( (v << shift_) & mask_ ); - *y() = (*y() & ~mask_) | pixel_value; - } - - void set( value_type v, difference_type d ) const - { - const value_type pixel_value( (v << shift_) & mask_ ); - *y(d) = (*y(d) & ~mask_) | pixel_value; - } -}; - -template< typename Valuetype, - int bits_per_pixel, - bool MsbFirst > class PackedPixelRowIterator : public NonStandardIterator -{ -public: - // no reference, no index_reference type here - typedef Valuetype value_type; - typedef int difference_type; - typedef image_traverser_tag iterator_category; - - typedef typename remove_const::type mask_type; - typedef value_type* pointer; - - enum { - /** The number of pixel within a single value_type value - */ - num_intraword_positions=sizeof(value_type)*8/bits_per_pixel, - /** Bit mask for one pixel (least significant bits) - */ - bit_mask=~(~0 << bits_per_pixel) - }; - -private: - pointer data_; - mask_type mask_; - difference_type remainder_; - - void update_mask() - { - mask_ = get_mask(remainder_); - } - - void inc() - { - const difference_type newValue( remainder_ + 1 ); - const difference_type data_offset( newValue / num_intraword_positions ); - - data_ += data_offset; - remainder_ = newValue % num_intraword_positions; - - const mask_type shifted_mask( - MsbFirst ? - unsigned_cast(mask_) >> bits_per_pixel : - mask_ << bits_per_pixel ); - - // data_offset is 0 for shifted mask, and 1 for wrapped-around mask - mask_ = (1-data_offset)*shifted_mask + data_offset*(MsbFirst ? - bit_mask << bits_per_pixel*(num_intraword_positions-1) : - bit_mask); - } - - void dec() - { - const difference_type newValue( remainder_ - 1 ); - const bool isNegative( is_negative(newValue) ); - const difference_type newRemainder( newValue % num_intraword_positions ); - - // calc data_ += newValue / num_intraword_positions; - // remainder_ = newRemainder; - // for newValue >= 0, and - // data_ += newValue / num_intraword_positions - 1; - // remainder_ = num_intraword_positions - newRemainder; - // (to force remainder_ to be positive). - // This is branch-free, if is_negative() is branch-free - const difference_type data_offset( newValue / num_intraword_positions - isNegative ); - data_ += data_offset; - remainder_ = newRemainder + isNegative*num_intraword_positions; - - const mask_type shifted_mask( - MsbFirst ? - mask_ << bits_per_pixel : - unsigned_cast(mask_) >> bits_per_pixel ); - - // data_offset is 0 for shifted mask, and 1 for wrapped-around mask - mask_ = (1-data_offset)*shifted_mask + data_offset*(MsbFirst ? - bit_mask : - bit_mask << bits_per_pixel*(num_intraword_positions-1)); - } - - bool equal( PackedPixelRowIterator const & rhs ) const - { - return rhs.data_ == data_ && rhs.remainder_ == remainder_; - } - - bool less( PackedPixelRowIterator const & rhs ) const - { - return data_ == rhs.data_ ? - (remainder_ < rhs.remainder_) : - (data_ < rhs.data_); - } - -public: - PackedPixelRowIterator() : - data_(0), - mask_( get_mask(0) ), - remainder_(0) - {} - - explicit PackedPixelRowIterator( pointer base, int x ) : - data_(base), - mask_(0), - remainder_(x % num_intraword_positions) - { - update_mask(); - } - - PackedPixelRowIterator& operator+=( difference_type d ) - { - const difference_type newValue( remainder_ + d ); - const bool isNegative( is_negative(newValue) ); - const difference_type newRemainder( newValue % num_intraword_positions ); - - // calc data_ += newValue / num_intraword_positions; - // remainder_ = newRemainder; - // for newValue >= 0, and - // data_ += newValue / num_intraword_positions - 1; - // remainder_ = newRemainder + num_intraword_positions; - // (to force remainder_ to be positive). - // This is branch-free, if is_negative() is branch-free - data_ += newValue / num_intraword_positions - isNegative; - remainder_ = newRemainder + isNegative*num_intraword_positions; - update_mask(); - - return *this; - } - - PackedPixelRowIterator& operator-=( difference_type d ) - { - // forward to operator+= - which has to cope with negative - // values, anyway. - return *this += -d; - } - - PackedPixelRowIterator operator+( difference_type d ) - { - PackedPixelRowIterator res(*this); - res += d; - return res; - } - - PackedPixelRowIterator operator-( difference_type d ) - { - PackedPixelRowIterator res(*this); - res -= d; - return res; - } - - PackedPixelRowIterator& operator++() - { - inc(); - return *this; - } - - PackedPixelRowIterator& operator--() - { - dec(); - return *this; - } - - PackedPixelRowIterator operator++(int) - { - PackedPixelRowIterator res(*this); - inc(); - return res; - } - - PackedPixelRowIterator operator--(int) - { - PackedPixelRowIterator res(*this); - dec(); - return res; - } - - bool operator==(PackedPixelRowIterator const & rhs) const - { - return equal( rhs ); - } - - bool operator!=(PackedPixelRowIterator const & rhs) const - { - return !equal( rhs ); - } - - bool operator<(PackedPixelRowIterator const & rhs) const - { - return less(rhs); - } - - bool operator<=(PackedPixelRowIterator const & rhs) const - { - return !rhs.less(*this); - } - - bool operator>(PackedPixelRowIterator const & rhs) const - { - return rhs.less(*this); - } - - bool operator>=(PackedPixelRowIterator const & rhs) const - { - return !less(rhs); - } - - difference_type operator-(PackedPixelRowIterator const & rhs) const - { - return (data_ - rhs.data_)*num_intraword_positions + (remainder_ - rhs.remainder_); - } - - value_type get() const - { - return unsigned_cast(*data_ & mask_) >> - get_shift(remainder_); - } - - value_type get(difference_type d) const - { - PackedPixelRowIterator tmp(*this); - tmp += d; - return tmp.get(); - } - - void set( value_type v ) const - { - const value_type pixel_value( - (v << - get_shift(remainder_)) - & mask_ ); - *data_ = (*data_ & ~mask_) | pixel_value; - } - - void set( value_type v, difference_type d ) const - { - PackedPixelRowIterator tmp(*this); - tmp += d; - tmp.set(v); - } -}; - -/** 2D image iterator for packed pixel formats - - This iterator can be used for image formats that pack more than - one pixel into an machine data type (like one bit per pixel, eight - of which packed into one char) - */ -template< typename Valuetype, - int bits_per_pixel, - bool MsbFirst > class PackedPixelIterator : public NonStandardIterator -{ -public: - // no reference, no index_reference type here - typedef Valuetype value_type; - typedef vigra::Diff2D difference_type; - typedef image_traverser_tag iterator_category; - typedef PackedPixelRowIterator row_iterator; - typedef PackedPixelColumnIterator column_iterator; - - typedef value_type* pointer; - typedef int MoveX; - typedef StridedArrayIterator< value_type > MoveY; - - enum { - /** The number of pixel within a single value_type value - */ - num_intraword_positions=sizeof(value_type)*8/bits_per_pixel, - /** Bit mask for one pixel (least significant bits) - */ - bit_mask=~(~0 << bits_per_pixel) - }; - - // TODO(F2): direction of iteration (ImageIterator can be made to - // run backwards) - -private: - pointer current() const - { - return y() + (x / num_intraword_positions); - } - - pointer current(int dx, int dy) const - { - return y(dy) + ((x+dx)/num_intraword_positions); - } - - bool equal(PackedPixelIterator const & rhs) const - { - return (x == rhs.x) && (y == rhs.y); - } - -public: - PackedPixelIterator() : - x(0), - y(0) - {} - - PackedPixelIterator(pointer base, int ystride) : - x(0), - y(ystride,base) - {} - - bool operator==(PackedPixelIterator const & rhs) const - { - return equal(rhs); - } - - bool operator!=(PackedPixelIterator const & rhs) const - { - return !equal(rhs); - } - - difference_type operator-(PackedPixelIterator const & rhs) const - { - return difference_type(x - rhs.x, y - rhs.y); - } - - MoveX x; - MoveY y; - - PackedPixelIterator & operator+=(difference_type const & s) - { - x += s.x; - y += s.y; - return *this; - } - - PackedPixelIterator & operator-=(difference_type const & s) - { - x -= s.x; - y -= s.y; - return *this; - } - - PackedPixelIterator operator+(difference_type const & s) const - { - PackedPixelIterator ret(*this); - ret += s; - return ret; - } - - PackedPixelIterator operator-(difference_type const & s) const - { - PackedPixelIterator ret(*this); - ret -= s; - return ret; - } - - row_iterator rowIterator() const - { - return row_iterator(current(),x); - } - - column_iterator columnIterator() const - { - return column_iterator(MoveY(y, - x / num_intraword_positions), - x % num_intraword_positions); - } - - value_type get() const - { - const int remainder( x % num_intraword_positions ); - - return (unsigned_cast(*current() & - get_mask(remainder)) - >> get_shift(remainder)); - } - - value_type get(difference_type const & d) const - { - const int remainder( x(d.x) % num_intraword_positions ); - - return (unsigned_cast(*current(d.x,d.y) & - get_mask(remainder)) - >> get_shift(remainder)); - } - - void set( value_type v ) const - { - const int remainder( x % num_intraword_positions ); - const int mask( get_mask(remainder) ); - const value_type pixel_value( - (v << - get_shift(remainder)) - & mask ); - pointer p = current(); - *p = (*p & ~mask) | pixel_value; - } - - void set( value_type v, difference_type const & d ) const - { - const int remainder( (x + d.x) % num_intraword_positions ); - const int mask( get_mask(remainder) ); - const value_type pixel_value( - (v << - get_shift(remainder)) - & mask ); - pointer p = current(d.x,d.y); - *p = (*p & ~mask) | pixel_value; - } -}; - - - -// partial specialization for the accessor traits masked_accessor -// selector metafunction - can employ fast mask functor for the 1bpp -// case. -template< class Accessor, - class MaskAccessor, - class Iterator, - bool polarity, - bool MsbFirst > struct maskedAccessorSelector< Accessor, - MaskAccessor, - Iterator, - PackedPixelIterator< typename MaskAccessor::value_type, - 1, - MsbFirst >, - polarity > -{ - typedef TernarySetterFunctionAccessorAdapter< - Accessor, - MaskAccessor, - typename outputMaskFunctorSelector< - typename Accessor::value_type, - typename MaskAccessor::value_type, - polarity, - FastMask>::type > - type; -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_PACKEDPIXELITERATOR_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/paletteformats.hxx b/include/basebmp/paletteformats.hxx deleted file mode 100644 index 083164cd5ea6..000000000000 --- a/include/basebmp/paletteformats.hxx +++ /dev/null @@ -1,139 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_PALETTEFORMATS_HXX -#define INCLUDED_BASEBMP_PALETTEFORMATS_HXX - -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -namespace basebmp -{ - - - -/** Lookup index value for given color value in a PaletteImageAccessor - */ -template< class Accessor > struct ColorLookup -{ - typename Accessor::data_type operator()( const Accessor& acc, - typename Accessor::value_type v ) const - { - return acc.lookup(v); - } -}; - - - -// partial specialization of AccessorTraits for PaletteAccessor -template< class Accessor, typename ColorType > struct AccessorTraits< - PaletteImageAccessor< Accessor, ColorType > > -{ - /// value type of described accessor - typedef typename PaletteImageAccessor< Accessor, ColorType >::value_type value_type; - - /// Retrieve stand-alone color lookup function for given Accessor type - typedef ColorLookup< PaletteImageAccessor< Accessor, ColorType > > color_lookup; - - /// Retrieve raw pixel data accessor for given Accessor type - typedef Accessor raw_accessor; - - /** accessor for XOR setter access is disabled, since the results - * are usually completely unintended - you'll usually want to - * wrap an xor_accessor with a PaletteAccessor, not the other way - * around. - */ - typedef vigra::VigraFalseType xor_accessor; - - /** accessor for masked setter access is disabled, since the - * results are usually completely unintended - you'll usually - * want to wrap a masked_accessor with a PaletteAccessor, not the - * other way around. - */ - template< class MaskAccessor, - class Iterator, - class MaskIterator > struct masked_accessor - { - typedef vigra::VigraFalseType type; - }; -}; - - - -template< typename ColorType > struct PaletteAccessorSelector -{ - template< class Accessor > struct wrap_accessor - { - typedef PaletteImageAccessor< Accessor, ColorType > type; - }; -}; - - - -template< class Iterator, - class Accessor > struct PixelFormatTraitsTemplate_Palette -{ - typedef typename Iterator::value_type pixel_type; - typedef Iterator iterator_type; - typedef Accessor raw_accessor_type; - typedef PaletteAccessorSelector accessor_selector; -}; - -template< int BitsPerPixel, - bool MsbFirst > struct PixelFormatTraitsTemplate_PackedPalette : - public PixelFormatTraitsTemplate_Palette< - PackedPixelIterator< sal_uInt8, - BitsPerPixel, - MsbFirst >, - NonStandardAccessor< sal_uInt8 > > -{}; - - - -// 1bpp MSB -typedef PixelFormatTraitsTemplate_PackedPalette<1, true> PixelFormatTraits_PAL1_MSB; - -// 1bpp LSB -typedef PixelFormatTraitsTemplate_PackedPalette<1, false> PixelFormatTraits_PAL1_LSB; - -// 4bpp MSB -typedef PixelFormatTraitsTemplate_PackedPalette<4, true> PixelFormatTraits_PAL4_MSB; - -// 4bpp LSB -typedef PixelFormatTraitsTemplate_PackedPalette<4, false> PixelFormatTraits_PAL4_LSB; - -// 8bpp -typedef PixelFormatTraitsTemplate_Palette< - PixelIterator< sal_uInt8 >, - StandardAccessor< sal_uInt8 > > PixelFormatTraits_PAL8; - -} // namespace basebmp - -#endif // INCLUDED_BASEBMP_PALETTEFORMATS_HXX - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/paletteimageaccessor.hxx b/include/basebmp/paletteimageaccessor.hxx deleted file mode 100644 index d19cd0344e32..000000000000 --- a/include/basebmp/paletteimageaccessor.hxx +++ /dev/null @@ -1,162 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_PALETTEIMAGEACCESSOR_HXX -#define INCLUDED_BASEBMP_PALETTEIMAGEACCESSOR_HXX - -#include -#include - -#include -#include - -#include -#include - -namespace basebmp -{ - -/** Access pixel data via palette indirection - - @tpl Accessor - Raw accessor, to be used to actually access the pixel values - - @tpl ColorType - The color value type to use - e.g. the palette is an array of that - type - */ -template< class Accessor, typename ColorType > class PaletteImageAccessor -{ -public: - typedef typename Accessor::value_type data_type; - typedef ColorType value_type; - -#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS -// making all members public, if no member template friends -private: - template friend class PaletteImageAccessor; -#endif - - Accessor maAccessor; - const value_type* mpPalette; - std::size_t mnNumEntries; - -public: - PaletteImageAccessor() : - maAccessor(), - mpPalette(0), - mnNumEntries(0) - {} - - template< class A > explicit - PaletteImageAccessor( PaletteImageAccessor const& rSrc ) : - maAccessor( rSrc.maAccessor ), - mpPalette( rSrc.mpPalette ), - mnNumEntries( rSrc.mnNumEntries ) - {} - - PaletteImageAccessor( const value_type* pPalette, - std::size_t numEntries ) : - maAccessor(), - mpPalette(pPalette), - mnNumEntries(numEntries) - {} - - template< class T > PaletteImageAccessor( T accessor, - const value_type* pPalette, - std::size_t numEntries ) : - maAccessor(accessor), - mpPalette(pPalette), - mnNumEntries(numEntries) - {} - - - - Accessor const& getWrappedAccessor() const { return maAccessor; } - Accessor& getWrappedAccessor() { return maAccessor; } - - - - data_type lookup(value_type const& v) const - { - // TODO(P3): use table-based/octree approach here! - const value_type* best_entry; - const value_type* palette_end( mpPalette+mnNumEntries ); - if( (best_entry=std::find( mpPalette, palette_end, v)) != palette_end ) - return best_entry-mpPalette; - - const value_type* curr_entry( mpPalette ); - best_entry = curr_entry; - while( curr_entry != palette_end ) - { - if( ColorTraits::distance(*curr_entry, - *best_entry) - > ColorTraits::distance(*curr_entry, - v) ) - { - best_entry = curr_entry; - } - - ++curr_entry; - } - - return best_entry-mpPalette; - } - - - - template< class Iterator > - value_type operator()(Iterator const& i) const - { - return mpPalette[ maAccessor(i) ]; - } - - template< class Iterator, class Difference > - value_type operator()(Iterator const& i, Difference const& diff) const - { - return mpPalette[ maAccessor(i,diff) ]; - } - - - - template< typename V, class Iterator > - void set(V const& value, Iterator const& i) const - { - maAccessor.set( - lookup( - vigra::detail::RequiresExplicitCast::cast(value) ), - i ); - } - - template< typename V, class Iterator, class Difference > - void set(V const& value, Iterator const& i, Difference const& diff) const - { - maAccessor.set( - lookup( - vigra::detail::RequiresExplicitCast::cast(value) ), - i, - diff ); - } -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_PALETTEIMAGEACCESSOR_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/pixelformatadapters.hxx b/include/basebmp/pixelformatadapters.hxx deleted file mode 100644 index 3789b7eb0360..000000000000 --- a/include/basebmp/pixelformatadapters.hxx +++ /dev/null @@ -1,102 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_PIXELFORMATADAPTERS_HXX -#define INCLUDED_BASEBMP_PIXELFORMATADAPTERS_HXX - -#include -#include - -#include - -namespace basebmp -{ - -// convenience functionality, providing everything necessary for a new -// pixel format. simply plug in two conversion functors from/to a -// common color format. - -/** Accessor selection metafunction, used to wrap a given accessor - with one converting between the pixel and color types - - Use the nested template's typedef type, to retrieve an - AccessorAdapter which operates on a pixel value accessor, and - provides color values to the outside. - - Nested like this, to avoid template template parameters at other - places: an instantiated version of AccessorSelector can be passed - to other templates, which in turn can invoke the nested meta - function. - */ -template< typename Getter, - typename Setter > struct AccessorSelector -{ - template< typename Accessor > struct wrap_accessor - { - typedef UnaryFunctionAccessorAdapter< Accessor, - Getter, - Setter > type; - }; -}; - - - -/** Convert color value to pixel data type - */ -template< class Accessor, typename DataType > struct ColorConvert -{ - DataType operator()( const Accessor& acc, - typename Accessor::value_type v ) const - { - return acc.setter(v); - } -}; - - - -/** Macro generates partial specialization for color-conversion - UnaryFunctionAccessorAdapter, and the given getter/setter functors - */ -#define BASEBMP_SPECIALIZE_ACCESSORTRAITS(Getter,Setter) \ -template< class Accessor > struct AccessorTraits< \ - UnaryFunctionAccessorAdapter< Accessor, \ - Getter, \ - Setter > > \ -{ \ - typedef typename Accessor::value_type data_type; \ - typedef UnaryFunctionAccessorAdapter< \ - Accessor, \ - Getter, \ - Setter > accessor_type; \ - typedef typename accessor_type::value_type value_type; \ - typedef ColorConvert< accessor_type, \ - data_type > color_lookup; \ - typedef Accessor raw_accessor; \ - typedef vigra::VigraFalseType xor_accessor; \ - template< class MaskAccessor, \ - class Iterator, \ - class MaskIterator > struct masked_accessor\ - { typedef vigra::VigraFalseType type; }; \ -} - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_PIXELFORMATADAPTERS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/pixeliterator.hxx b/include/basebmp/pixeliterator.hxx deleted file mode 100644 index e629af275dd9..000000000000 --- a/include/basebmp/pixeliterator.hxx +++ /dev/null @@ -1,349 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_PIXELITERATOR_HXX -#define INCLUDED_BASEBMP_PIXELITERATOR_HXX - -#include -#include - -#include -#include - -namespace basebmp -{ - -template< typename Valuetype > class PixelColumnIterator -{ -public: - typedef Valuetype value_type; - typedef Valuetype& reference; - typedef reference index_reference; - typedef Valuetype* pointer; - typedef int difference_type; - typedef image_traverser_tag iterator_category; - - typedef StridedArrayIterator< value_type > MoveY; - -private: - MoveY y; - - bool equal( PixelColumnIterator const & rhs ) const - { - return rhs.y == y; - } - - bool less( PixelColumnIterator const & rhs ) const - { - return y < rhs.y; - } - -public: - PixelColumnIterator() : - y(0) - {} - - explicit PixelColumnIterator( const MoveY& pos ) : - y(pos) - {} - - PixelColumnIterator( const MoveY& pos, int x ) : - y(pos,x) - {} - - PixelColumnIterator& operator+=( difference_type d ) - { - y += d; - return *this; - } - - PixelColumnIterator& operator-=( difference_type d ) - { - y -= d; - return *this; - } - - PixelColumnIterator operator+( difference_type d ) - { - PixelColumnIterator res(*this); - res += d; - return res; - } - - PixelColumnIterator operator-( difference_type d ) - { - PixelColumnIterator res(*this); - res -= d; - return res; - } - - PixelColumnIterator& operator++() - { - ++y; - return *this; - } - - PixelColumnIterator& operator--() - { - --y; - return *this; - } - - PixelColumnIterator operator++(int) - { - PixelColumnIterator res(*this); - ++y; - return res; - } - - PixelColumnIterator operator--(int) - { - PixelColumnIterator res(*this); - --y; - return res; - } - - bool operator==(PixelColumnIterator const & rhs) const - { - return equal( rhs ); - } - - bool operator!=(PixelColumnIterator const & rhs) const - { - return !equal( rhs ); - } - - bool operator<(PixelColumnIterator const & rhs) const - { - return less(rhs); - } - - bool operator<=(PixelColumnIterator const & rhs) const - { - return !rhs.less(*this); - } - - bool operator>(PixelColumnIterator const & rhs) const - { - return rhs.less(*this); - } - - bool operator>=(PixelColumnIterator const & rhs) const - { - return !less(rhs); - } - - difference_type operator-(PixelColumnIterator const & rhs) const - { - return y - rhs.y; - } - - value_type get() const - { - return *y(); - } - - value_type get(difference_type d) const - { - return *y(d); - } - - void set( value_type v ) const - { - *y() = v; - } - - void set( value_type v, difference_type d ) const - { - *y(d) = v; - } - - reference operator*() const - { - return *y(); - } - - pointer operator->() const - { - return y(); - } - - reference operator[](difference_type d) const - { - return *y(d); - } - - reference operator()(int dy) const - { - return *y(dy); - } -}; - -template< typename Valuetype > class PixelIterator -{ -public: - typedef Valuetype value_type; - typedef Valuetype& reference; - typedef reference index_reference; - typedef Valuetype* pointer; - typedef vigra::Diff2D difference_type; - typedef image_traverser_tag iterator_category; - typedef pointer row_iterator; - typedef PixelColumnIterator column_iterator; - - typedef int MoveX; - typedef StridedArrayIterator< value_type > MoveY; - - // TODO(F2): direction of iteration (ImageIterator can be made to - // run backwards) - -private: - bool equal(PixelIterator const & rhs) const - { - return (x == rhs.x) && (y == rhs.y); - } - - pointer current() const - { - return y() + x; - } - - pointer current(int dx, int dy) const - { - return y(dy) + x+dx; - } - -public: - PixelIterator() : - x(0), - y(0) - {} - - PixelIterator(pointer base, int ystride) : - x(0), - y(ystride,base) - {} - - bool operator==(PixelIterator const & rhs) const - { - return equal(rhs); - } - - bool operator!=(PixelIterator const & rhs) const - { - return !equal(rhs); - } - - difference_type operator-(PixelIterator const & rhs) const - { - return difference_type(x - rhs.x, y - rhs.y); - } - - MoveX x; - MoveY y; - - PixelIterator & operator+=(difference_type const & s) - { - x += s.x; - y += s.y; - return *this; - } - - PixelIterator & operator-=(difference_type const & s) - { - x -= s.x; - y -= s.y; - return *this; - } - - PixelIterator operator+(difference_type const & s) const - { - PixelIterator ret(*this); - ret += s; - return ret; - } - - PixelIterator operator-(difference_type const & s) const - { - PixelIterator ret(*this); - ret -= s; - return ret; - } - - row_iterator rowIterator() const - { - return row_iterator(y()+x); - } - - column_iterator columnIterator() const - { - return column_iterator(y,x); - } - - value_type get() const - { - return *current(); - } - - value_type get(difference_type const & d) const - { - return *current(d.y, d.x); - } - - void set( value_type v ) const - { - *current() = v; - } - - void set( value_type v, difference_type const & d ) const - { - *current(d.y,d.x) = v; - } - - reference operator*() const - { - return *current(); - } - - pointer operator->() const - { - return current(); - } - - reference operator[]( const vigra::Diff2D& d ) const - { - return *current(d.x,d.y); - } - - reference operator()(int dx, int dy) const - { - return *current(dx,dy); - } - - pointer operator[](int dy) const - { - return y(dy) + x; - } -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_PIXELITERATOR_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/polypolygonrenderer.hxx b/include/basebmp/polypolygonrenderer.hxx deleted file mode 100644 index 88963ae0be9f..000000000000 --- a/include/basebmp/polypolygonrenderer.hxx +++ /dev/null @@ -1,360 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_POLYPOLYGONRENDERER_HXX -#define INCLUDED_BASEBMP_POLYPOLYGONRENDERER_HXX - -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include - - -namespace basebmp -{ - namespace detail - { - /// convert int32 to 32:32 fixed point - inline sal_Int64 toFractional( sal_Int32 v ) { return sal_Int64(sal_uInt64(v) << 32); } - /// convert double to 32:32 fixed point - inline sal_Int64 toFractional( double v ) { return (sal_Int64)(v*SAL_MAX_UINT32 + (v < 0.0 ? -0.5 : 0.5 )); } - /// convert 32:32 fixed point to int32 (truncate) - inline sal_Int32 toInteger( sal_Int64 v ) { return (sal_Int32)(v < 0 ? ~((~v) >> 32) : v >> 32); } - /// convert 32:32 fixed point to int32 (properly rounded) - inline sal_Int32 toRoundedInteger( sal_Int64 v ) { return toInteger(v) + (sal_Int32)((v&0x80000000) >> 31); } - - /** internal vertex store - - - Different from B2DPoint, since we don't need floating - point coords, but orientation of vertex and y counter - */ - struct Vertex - { - sal_Int32 mnYCounter; - sal_Int64 mnX; - sal_Int64 mnXDelta; - - bool mbDownwards; // needed for nonzero winding rule - // fills - - Vertex() : - mnYCounter(0), - mnX(0), - mnXDelta(0), - mbDownwards(true) - {} - Vertex( basegfx::B2DPoint const& rPt1, - basegfx::B2DPoint const& rPt2, - bool bDownwards ) : - mnYCounter( basegfx::fround(rPt2.getY()) - - basegfx::fround(rPt1.getY()) ), - mnX( toFractional( basegfx::fround(rPt1.getX()) )), - mnXDelta( toFractional( - ((rPt2.getX() - rPt1.getX()) / - (double)mnYCounter) )), - mbDownwards(bDownwards) - {} - }; - - typedef std::vector< std::vector > VectorOfVectorOfVertices; - typedef std::vector< Vertex* > VectorOfVertexPtr; - - /// non-templated setup of GET - sal_uInt32 setupGlobalEdgeTable( VectorOfVectorOfVertices& rGET, - basegfx::B2DPolyPolygon const& rPoly, - sal_Int32 nMinY ); - /// sort rAETSrc, copy not-yet-ended edges over to rAETDest - void sortAET( VectorOfVertexPtr& rAETSrc, - VectorOfVertexPtr& rAETDest ); - - /// For the STL algorithms - struct RasterConvertVertexComparator - { - RasterConvertVertexComparator() {} - - bool operator()( const Vertex& rLHS, - const Vertex& rRHS ) const - { - return rLHS.mnX < rRHS.mnX; - } - - bool operator()( const Vertex* pLHS, - const Vertex* pRHS ) const - { - return pLHS->mnX < pRHS->mnX; - } - }; - - } // namespace detail - - - /** Raster-convert a poly-polygon. - - This algorithm does not perform antialiasing, and thus - internally works with integer vertex coordinates. - - @param begin - Left, top edge of the destination bitmap. This position is - considered (0,0) relative to all polygon vertices - - @param ad - Accessor to set pixel values - - @param fillColor - Color to use for filling - - @param rClipRect - Clipping rectangle, relative to the begin iterator. No pixel outside - this clip rect will be modified. - - @param rPoly - Polygon to fill - */ - template< class DestIterator, class DestAccessor, typename T > - void renderClippedPolyPolygon( DestIterator begin, - DestAccessor ad, - T fillColor, - const basegfx::B2IBox& rClipRect, - basegfx::B2DPolyPolygon const& rPoly, - basegfx::FillRule eFillRule ) - { - const sal_Int32 nClipX1( std::max((sal_Int32)0,rClipRect.getMinX()) ); - const sal_Int32 nClipX2( rClipRect.getMaxX() ); - const sal_Int32 nClipY1( std::max((sal_Int32)0,rClipRect.getMinY()) ); - const sal_Int32 nClipY2( rClipRect.getMaxY() ); - const sal_Int64 nClipX1_frac( detail::toFractional(nClipX1) ); - const sal_Int64 nClipX2_frac( detail::toFractional(nClipX2) ); - - basegfx::B2DRange const aPolyBounds( basegfx::tools::getRange(rPoly) ); - - const sal_Int32 nMinY( basegfx::fround(aPolyBounds.getMinY()) ); - const sal_Int32 nMaxY( - std::min( - nClipY2-1, - basegfx::fround(aPolyBounds.getMaxY()))); - - if( nMinY > nMaxY ) - return; // really, nothing to do then. - - detail::VectorOfVectorOfVertices aGET; // the Global Edge Table - aGET.resize( nMaxY - nMinY + 1 ); - - sal_uInt32 const nVertexCount( - detail::setupGlobalEdgeTable( aGET, rPoly, nMinY ) ); - - - // Perform actual scan conversion - - - if( aGET.empty() ) - return; - - detail::VectorOfVertexPtr aAET1; // the Active Edge Table - detail::VectorOfVertexPtr aAET2; - detail::VectorOfVertexPtr* pAET = &aAET1; - detail::VectorOfVertexPtr* pAETOther = &aAET2; - aAET1.reserve( nVertexCount ); - aAET2.reserve( nVertexCount ); - - // current scanline - initially, points to first scanline - // within the clip rect, or to the polygon's first scanline - // (whichever is greater) - DestIterator aScanline( begin + - vigra::Diff2D( - 0, - std::max(nMinY, - nClipY1)) ); - detail::RasterConvertVertexComparator aComp; - - - // now process each of the nMaxY - nMinY + 1 scanlines - - - for( sal_Int32 y=nMinY; y <= nMaxY; ++y ) - { - if( !aGET[y-nMinY].empty() ) - { - // merge AET with current scanline's new vertices (both - // are already correctly sorted) - detail::VectorOfVectorOfVertices::value_type::iterator vertex=aGET[y-nMinY].begin(); - detail::VectorOfVectorOfVertices::value_type::iterator const end=aGET[y-nMinY].end(); - while( vertex != end ) - { - // find insertion pos by binary search, and put ptr - // into active edge vector - pAET->insert( std::lower_bound( pAET->begin(), - pAET->end(), - &(*vertex), - aComp ), - &(*vertex) ); - - ++vertex; - } - } - - // with less than two active edges, no fill visible - if( pAET->size() >= 2 ) - { - typename vigra::IteratorTraits::row_iterator - rowIter( aScanline.rowIterator() ); - - // process each span in current scanline, with - // even-odd fill rule - detail::VectorOfVertexPtr::iterator currVertex( pAET->begin() ); - detail::VectorOfVertexPtr::iterator const lastVertex( pAET->end()-1 ); - sal_uInt32 nCrossedEdges(0); - sal_Int32 nWindingNumber(0); - while( currVertex != lastVertex ) - { - // TODO(P1): might be worth a try to extend the - // size()==2 case also to the actual filling - // here. YMMV. - detail::Vertex& rV1( **currVertex ); - detail::Vertex const& rV2( **++currVertex ); - - nWindingNumber += -1 + 2*int(rV1.mbDownwards); - - // calc fill status for both rules. might save a - // few percent runtime to specialize here... - const bool bEvenOddFill( - eFillRule == basegfx::FillRule_EVEN_ODD && !(nCrossedEdges & 0x01) ); - const bool bNonZeroWindingFill( - eFillRule == basegfx::FillRule_NONZERO_WINDING_NUMBER && nWindingNumber != 0 ); - - // is span visible? - if( (bEvenOddFill || bNonZeroWindingFill) && - y >= nClipY1 && - rV1.mnX < nClipX2_frac && - rV2.mnX > nClipX1_frac ) - { - // clip span to horizontal bounds - sal_Int32 const nStartX( - std::max( nClipX1, - std::min( nClipX2-1, - detail::toRoundedInteger(rV1.mnX) ))); - sal_Int32 const nEndX( - std::max( nClipX1, - std::min( nClipX2, - detail::toRoundedInteger(rV2.mnX) ))); - - typename vigra::IteratorTraits::row_iterator - currPix( rowIter + nStartX); - typename vigra::IteratorTraits::row_iterator - rowEnd( rowIter + nEndX ); - - // TODO(P2): Provide specialized span fill methods on the - // iterator/accessor - while( currPix != rowEnd ) - ad.set(fillColor, currPix++); - } - - // step vertices - rV1.mnX += rV1.mnXDelta; - --rV1.mnYCounter; - - ++nCrossedEdges; - } - - // step vertex also for the last one - detail::Vertex& rLastV( **currVertex ); - rLastV.mnX += rLastV.mnXDelta; - --rLastV.mnYCounter; - - - // prune AET from ended edges, and keep it sorted - - - pAETOther->clear(); - if( pAET->size() == 2 ) - { - // the case of exactly two active edges is both - // sufficiently common (all 'simple' polygons have - // it), and further more would complicate the - // generic case below (which works with a sliding - // triple of vertices). - if( !aComp(*(*pAET)[0], *(*pAET)[1]) ) - std::swap(*(*pAET)[0], *(*pAET)[1]); - - if( (*pAET)[0]->mnYCounter > 0 ) - pAETOther->push_back( (*pAET)[0] ); - if( (*pAET)[1]->mnYCounter > 0 ) - pAETOther->push_back( (*pAET)[1] ); - } - else - { - bool bFallbackTaken(false); - currVertex = pAET->begin(); - detail::VectorOfVertexPtr::iterator prevVertex( currVertex ); - while( currVertex != lastVertex ) - { - // try to get away with one linear swoop and - // simple neighbor swapping. this is an - // overwhelmingly common case - polygons with - // excessively crisscrossing edges (which on - // top of that cross more than one other edge - // per scanline) are seldom. And even if we - // get such a beast here, this extra loop has - // still only linear cost - if( aComp(**(currVertex+1),**currVertex) ) - { - std::swap(*currVertex, *(currVertex+1)); - - if( aComp(**currVertex,**prevVertex) ) - { - // one swap was not sufficient - - // fallback to generic sort algo, then - detail::sortAET(*pAET, *pAETOther); - bFallbackTaken = true; - break; - } - } - - if( (*currVertex)->mnYCounter > 0 ) - pAETOther->push_back( *currVertex ); - - prevVertex = currVertex++; - } - - // don't forget to add last vertex (loop above - // only deals with n-1 vertices) - if( !bFallbackTaken && (*currVertex)->mnYCounter > 0 ) - pAETOther->push_back( *currVertex ); - } - - std::swap( pAET, pAETOther ); - } - - if( y >= nClipY1 ) - ++aScanline.y; - } - } - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_POLYPOLYGONRENDERER_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/rgb24pixelformats.hxx b/include/basebmp/rgb24pixelformats.hxx deleted file mode 100644 index 50c110a0dfd9..000000000000 --- a/include/basebmp/rgb24pixelformats.hxx +++ /dev/null @@ -1,92 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_RGB24PIXELFORMATS_HXX -#define INCLUDED_BASEBMP_RGB24PIXELFORMATS_HXX - -#include -#include -#include -#include - -#include - -#include - -namespace basebmp -{ - -template< typename PixelType, typename ColorType > struct RGBValueGetter : - public std::unary_function -{ - ColorType operator()( PixelType const& c ) const - { - return ColorType(c.red(),c.green(),c.blue()); - } -}; - -template< typename PixelType, typename ColorType > struct RGBValueSetter : - public std::unary_function -{ - PixelType operator()( ColorType const& c ) const - { - PixelType res; - res.setRed(c.getRed()); - res.setGreen(c.getGreen()); - res.setBlue(c.getBlue()); - return res; - } -}; - - - -template< typename PixelType > struct PixelFormatTraitsTemplate_RGBValue -{ - typedef PixelType pixel_type; - - typedef RGBValueGetter getter_type; - typedef RGBValueSetter setter_type; - - typedef PixelIterator iterator_type; - typedef StandardAccessor raw_accessor_type; - typedef AccessorSelector< - getter_type, setter_type> accessor_selector; -}; - - - -// 24bpp RGB -typedef PixelFormatTraitsTemplate_RGBValue< - vigra::RGBValue > PixelFormatTraits_RGB24; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_RGB24::getter_type, - PixelFormatTraits_RGB24::setter_type); - -// 24bpp BGR -typedef PixelFormatTraitsTemplate_RGBValue< - vigra::RGBValue > PixelFormatTraits_BGR24; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_BGR24::getter_type, - PixelFormatTraits_BGR24::setter_type); - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_RGB24PIXELFORMATS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/rgbmaskpixelformats.hxx b/include/basebmp/rgbmaskpixelformats.hxx deleted file mode 100644 index 262b17ea983b..000000000000 --- a/include/basebmp/rgbmaskpixelformats.hxx +++ /dev/null @@ -1,355 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_RGBMASKPIXELFORMATS_HXX -#define INCLUDED_BASEBMP_RGBMASKPIXELFORMATS_HXX - -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include - -namespace basebmp -{ - -/** Base class operating on RGB truecolor mask pixel - - Use this template, if you have an (integer) pixel type, and three - bitmasks denoting where the channel bits are. - - @tpl PixelType - Input pixel type to operate on - - @tpl ColorType - Underlying color type, to convert the pixel values into - - @tpl RedMask - Bitmask, to access the red bits in the data type - - @tpl GreenMask - Bitmask, to access the green bits in the data type - - @tpl BlueMask - Bitmask, to access the blue bits in the data type - - @tpl SwapBytes - When true, the final pixel values will be byte-swapped before - passed on. - */ -template< typename PixelType, - typename ColorType, - unsigned int RedMask, - unsigned int GreenMask, - unsigned int BlueMask, - bool SwapBytes > struct RGBMaskFunctorBase -{ - typedef PixelType pixel_type; - typedef ColorType color_type; - typedef typename make_unsigned::type unsigned_pixel_type; - typedef typename ColorTraits::component_type component_type; - - // calc corrective shifts for all three channels in advance - enum { - red_shift = numberOfTrailingZeros::value, - green_shift = numberOfTrailingZeros::value, - blue_shift = numberOfTrailingZeros::value, - - red_bits = bitcount::value, - green_bits = bitcount::value, - blue_bits = bitcount::value - }; -}; - -template< typename PixelType, - typename ColorType, - unsigned int RedMask, - unsigned int GreenMask, - unsigned int BlueMask, - bool SwapBytes > struct RGBMaskGetter : - public RGBMaskFunctorBase, - public std::unary_function -{ - typedef RGBMaskFunctorBase base_type; - - ColorType operator()( PixelType v ) const - { - v = SwapBytes ? byteSwap(v) : v; - - const typename base_type::unsigned_pixel_type red (v & RedMask); - const typename base_type::unsigned_pixel_type green(v & GreenMask); - const typename base_type::unsigned_pixel_type blue (v & BlueMask); - - // shift color nibbles to right-aligned position. ORing it - // channel value shifted twice the number of channel bits, to - // spread the value into the component_type range - ColorType res( (shiftRight(red, - base_type::red_shift-8* - static_cast(sizeof(typename base_type::component_type))+ - base_type::red_bits)) | - (shiftRight(red, - base_type::red_shift-8* - static_cast(sizeof(typename base_type::component_type))+ - 2*base_type::red_bits)), - - (shiftRight(green, - base_type::green_shift-8* - static_cast(sizeof(typename base_type::component_type))+ - base_type::green_bits)) | - (shiftRight(green, - base_type::green_shift-8* - static_cast(sizeof(typename base_type::component_type))+ - 2*base_type::green_bits)), - - (shiftRight(blue, - base_type::blue_shift-8* - static_cast(sizeof(typename base_type::component_type))+ - base_type::blue_bits)) | - (shiftRight(blue, - base_type::blue_shift-8* - static_cast(sizeof(typename base_type::component_type))+ - 2*base_type::blue_bits)) ); - return res; - } -}; - -template< typename PixelType, - typename ColorType, - unsigned int BaseValue, - unsigned int RedMask, - unsigned int GreenMask, - unsigned int BlueMask, - bool SwapBytes > struct RGBMaskSetter : - public RGBMaskFunctorBase, - public std::unary_function -{ - typedef RGBMaskFunctorBase base_type; - - PixelType operator()( ColorType const& c ) const - { - const typename base_type::unsigned_pixel_type red (c.getRed()); - const typename base_type::unsigned_pixel_type green(c.getGreen()); - const typename base_type::unsigned_pixel_type blue (c.getBlue()); - - typename base_type::unsigned_pixel_type res( - BaseValue | - (shiftLeft(red, - base_type::red_shift-8* - static_cast(sizeof(typename base_type::component_type))+ - base_type::red_bits) & RedMask) | - (shiftLeft(green, - base_type::green_shift-8* - static_cast(sizeof(typename base_type::component_type))+ - base_type::green_bits) & GreenMask) | - (shiftLeft(blue, - base_type::blue_shift-8* - static_cast(sizeof(typename base_type::component_type))+ - base_type::blue_bits) & BlueMask) ); - - return SwapBytes ? byteSwap(res) : res; - } -}; - - - -template< typename PixelType, - unsigned int BaseValue, - unsigned int RedMask, - unsigned int GreenMask, - unsigned int BlueMask, - bool SwapBytes > struct PixelFormatTraitsTemplate_RGBMask -{ - typedef PixelType pixel_type; - - typedef RGBMaskGetter getter_type; - typedef RGBMaskSetter setter_type; - - typedef PixelIterator iterator_type; - typedef StandardAccessor raw_accessor_type; - typedef AccessorSelector< - getter_type, setter_type> accessor_selector; -}; - - - -// Hopefully this is an understandable plaintext explanation that matches -// reality... - -// BASEBMP_TRUECOLORMASK_LSB_SWAP means that on a big-endian platform, a pixel -// value when viewed as an integer (16 or 32 bits) has to be byte-swapped for -// the channels to match the masks. Or equivalently (I think), on a big-endian -// platform, the masks need to be byte-swapped to be correct. - -// I.e. on a litte-endian platform the masks work as such. - -// BASEBMP_TRUECOLORMASK_MSB_SWAP means the opposite. The masks work as such -// on big-endian platforms, on little-endian platforms the pixel needs to be -// byte-swapped for the masks to work. - -// So in a sense these two names are "backward". It sounds to me as if -// BASEBMP_TRUECOLORMASK_LSB_SWAP would mean "when on LSB, swap" ;) - -#ifdef OSL_LITENDIAN -# define BASEBMP_TRUECOLORMASK_LSB_SWAP false -# define BASEBMP_TRUECOLORMASK_MSB_SWAP true -#else -# ifdef OSL_BIGENDIAN -# define BASEBMP_TRUECOLORMASK_LSB_SWAP true -# define BASEBMP_TRUECOLORMASK_MSB_SWAP false -# else -# error Undetermined endianness! -# endif -#endif - - - -// 16bpp MSB RGB -typedef PixelFormatTraitsTemplate_RGBMask< - sal_uInt16, - 0, - 0xF800, - 0x07E0, - 0x001F, - BASEBMP_TRUECOLORMASK_MSB_SWAP > PixelFormatTraits_RGB16_565_MSB; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_RGB16_565_MSB::getter_type, - PixelFormatTraits_RGB16_565_MSB::setter_type); - -// 16bpp LSB RGB -typedef PixelFormatTraitsTemplate_RGBMask< - sal_uInt16, - 0, - 0xF800, - 0x07E0, - 0x001F, - BASEBMP_TRUECOLORMASK_LSB_SWAP > PixelFormatTraits_RGB16_565_LSB; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_RGB16_565_LSB::getter_type, - PixelFormatTraits_RGB16_565_LSB::setter_type); - - -// 32bpp formats - -// The intent is that the order of channel names in the names of the 32bpp -// format typedefs below correspond to the order of the channel bytes in -// memory, if I understand correctly.... I think the point with the below -// formats is that the channel byte order in memory is the same regardless of -// platform byte order. - -// This one used to be called PixelFormatTraits_RGB32_888. - -typedef PixelFormatTraitsTemplate_RGBMask< - sal_uInt32, - 0xFF000000, - 0x00FF0000, - 0x0000FF00, - 0x000000FF, - BASEBMP_TRUECOLORMASK_LSB_SWAP > PixelFormatTraits_BGRA32_8888; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_BGRA32_8888::getter_type, - PixelFormatTraits_BGRA32_8888::setter_type); - -// This one used to be called PixelFormatTraits_BGR32_888. - -typedef PixelFormatTraitsTemplate_RGBMask< - sal_uInt32, - 0xFF000000, - 0x00FF0000, - 0x0000FF00, - 0x000000FF, - BASEBMP_TRUECOLORMASK_MSB_SWAP > PixelFormatTraits_ARGB32_8888; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_ARGB32_8888::getter_type, - PixelFormatTraits_ARGB32_8888::setter_type); - -// The following two ones were added for Android needs and for completeness - -typedef PixelFormatTraitsTemplate_RGBMask< - sal_uInt32, - 0x000000FF, - 0xFF000000, - 0x00FF0000, - 0x0000FF00, - BASEBMP_TRUECOLORMASK_LSB_SWAP > PixelFormatTraits_ABGR32_8888; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_ABGR32_8888::getter_type, - PixelFormatTraits_ABGR32_8888::setter_type); - -typedef PixelFormatTraitsTemplate_RGBMask< - sal_uInt32, - 0x000000FF, - 0xFF000000, - 0x00FF0000, - 0x0000FF00, - BASEBMP_TRUECOLORMASK_MSB_SWAP > PixelFormatTraits_RGBA32_8888; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_RGBA32_8888::getter_type, - PixelFormatTraits_RGBA32_8888::setter_type); - -// Added for Cairo needs, perhaps Android should get an XRGB and replace -// some uses of ARGB with that instead ? - -typedef PixelFormatTraitsTemplate_RGBMask< - sal_uInt32, - 0x00000000, - 0x00FF0000, - 0x0000FF00, - 0x000000FF, - BASEBMP_TRUECOLORMASK_LSB_SWAP > PixelFormatTraits_BGRX32_8888; -BASEBMP_SPECIALIZE_ACCESSORTRAITS(PixelFormatTraits_BGRX32_8888::getter_type, - PixelFormatTraits_BGRX32_8888::setter_type); - - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_RGBMASKPIXELFORMATS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/scaleimage.hxx b/include/basebmp/scaleimage.hxx deleted file mode 100644 index fc9022357fe6..000000000000 --- a/include/basebmp/scaleimage.hxx +++ /dev/null @@ -1,189 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_SCALEIMAGE_HXX -#define INCLUDED_BASEBMP_SCALEIMAGE_HXX - -#include - -#include -#include -#include -#include - -namespace basebmp -{ - -template< class SourceIter, class SourceAcc, - class DestIter, class DestAcc > -void scaleLine( SourceIter s_begin, - SourceIter s_end, - SourceAcc s_acc, - DestIter d_begin, - DestIter d_end, - DestAcc d_acc ) -{ - const int src_width = s_end - s_begin; - const int dest_width = d_end - d_begin; - - OSL_ASSERT( src_width > 0 && dest_width > 0 ); - - if( src_width >= dest_width ) - { - // shrink - int rem = 0; - while( s_begin != s_end ) - { - if( rem >= 0 ) - { - d_acc.set( s_acc(s_begin), d_begin ); - - rem -= src_width; - ++d_begin; - } - - rem += dest_width; - ++s_begin; - } - } - else - { - // enlarge - int rem = -dest_width; - while( d_begin != d_end ) - { - if( rem >= 0 ) - { - rem -= dest_width; - ++s_begin; - } - - d_acc.set( s_acc(s_begin), d_begin ); - - rem += src_width; - ++d_begin; - } - } -} - -/** Scale an image using zero order interpolation (pixel replication) - - Source and destination range must be at least one pixel wide and - high. - - @param s_begin - Start iterator for source image - - @param s_end - End iterator for source image - - @param s_acc - Source accessor - - @param d_begin - Start iterator for destination image - - @param d_end - End iterator for destination image - - @param d_acc - Destination accessor - - @param bMustCopy - When true, scaleImage always copies source, even when doing 1:1 - copy - */ -template< class SourceIter, class SourceAcc, - class DestIter, class DestAcc > -void scaleImage( SourceIter s_begin, - SourceIter s_end, - SourceAcc s_acc, - DestIter d_begin, - DestIter d_end, - DestAcc d_acc, - bool bMustCopy=false ) -{ - const int src_width ( s_end.x - s_begin.x ); - const int src_height( s_end.y - s_begin.y ); - - const int dest_width ( d_end.x - d_begin.x ); - const int dest_height( d_end.y - d_begin.y ); - - if( !bMustCopy && - src_width == dest_width && - src_height == dest_height ) - { - // no scaling involved, can simply copy - vigra::copyImage( s_begin, s_end, s_acc, - d_begin, d_acc ); - return; - } - - typedef vigra::BasicImage TmpImage; - typedef typename TmpImage::traverser TmpImageIter; - - TmpImage tmp_image(src_width, - dest_height); - TmpImageIter t_begin = tmp_image.upperLeft(); - - // scale in y direction - for( int x=0; x -inline void scaleImage( vigra::triple const& src, - vigra::triple const& dst, - bool bMustCopy=false ) -{ - scaleImage(src.first,src.second,src.third, - dst.first,dst.second,dst.third, - bMustCopy); -} - -} - -#endif /* INCLUDED_BASEBMP_SCALEIMAGE_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/stridedarrayiterator.hxx b/include/basebmp/stridedarrayiterator.hxx deleted file mode 100644 index 6f5772e527c6..000000000000 --- a/include/basebmp/stridedarrayiterator.hxx +++ /dev/null @@ -1,108 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_STRIDEDARRAYITERATOR_HXX -#define INCLUDED_BASEBMP_STRIDEDARRAYITERATOR_HXX - -#include - -namespace basebmp -{ - -/** Like vigra::StridedArrayIterator - - Changed semantics re. DirectionSelector: stride - now counts in raw bytes - - Adapts given ptr, in a way that iterator increments move forward - in strided steps. Stride can, by the way, also be negative - */ -template< typename T > class StridedArrayIterator -{ -public: - typedef typename clone_const::type internal_type; - - /** Create iterator - - @param stride - - Stride in bytes. Given value should better match memory layout - of T, as memory gets reinterpret-casted. - */ - explicit StridedArrayIterator(int stride, T* ptr = 0) : - stride_(stride), - current_(reinterpret_cast(ptr)) - {} - - /** Copy from other StridedArrayIterator, plus given offset - - @param offset - Offset in bytes - */ - StridedArrayIterator( StridedArrayIterator const& rSrc, - int offset ) : - stride_(rSrc.stride_), - current_(reinterpret_cast( - reinterpret_cast(rSrc.current_)+offset)) - {} - - void operator++() {current_ += stride_; } - void operator++(int) {current_ += stride_; } - void operator--() {current_ -= stride_; } - void operator--(int) {current_ -= stride_; } - void operator+=(int dy) {current_ += dy*stride_; } - void operator-=(int dy) {current_ -= dy*stride_; } - - int operator-(StridedArrayIterator const & rhs) const - { return (current_ - rhs.current_) / stride_; } - - bool operator==(StridedArrayIterator const & rhs) const - { return current_ == rhs.current_; } - - bool operator!=(StridedArrayIterator const & rhs) const - { return current_ != rhs.current_; } - - bool operator<(StridedArrayIterator const & rhs) const - { return *this - rhs < 0; } - - bool operator<=(StridedArrayIterator const & rhs) const - { return *this - rhs <= 0; } - - bool operator>(StridedArrayIterator const & rhs) const - { return *this - rhs > 0; } - - bool operator>=(StridedArrayIterator const & rhs) const - { return *this - rhs >= 0; } - - T* operator()() const - { return reinterpret_cast(current_); } - - T* operator()(int d) const - { return reinterpret_cast(current_ + d*stride_); } - -private: - int stride_; - internal_type* current_; -}; - -} // namespace basebmp - -#endif /* INCLUDED_BASEBMP_STRIDEDARRAYITERATOR_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basebmp/tools.hxx b/include/basebmp/tools.hxx deleted file mode 100644 index 31854a1d5e25..000000000000 --- a/include/basebmp/tools.hxx +++ /dev/null @@ -1,85 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_BASEBMP_TOOLS_HXX -#define INCLUDED_BASEBMP_TOOLS_HXX - -#include -#include -#include -#include - -namespace basebmp -{ - inline vigra::Diff2D topLeft( const basegfx::B2IBox& rRange ) - { return vigra::Diff2D(rRange.getMinX(),rRange.getMinY()); } - - inline vigra::Diff2D bottomRight( const basegfx::B2IBox& rRange ) - { return vigra::Diff2D(rRange.getMaxX(),rRange.getMaxY()); } - - template< class Iterator, class Accessor > - inline vigra::triple - destIterRange(Iterator const& begin, - Accessor const& accessor, - const basegfx::B2IBox& rRange) - { - return vigra::triple( - begin + topLeft(rRange), - begin + bottomRight(rRange), - accessor); - } - - template< class Iterator, class Accessor > - inline vigra::triple - srcIterRange(Iterator const& begin, - Accessor const& accessor, - const basegfx::B2IBox& rRange) - { - return vigra::triple( - begin + topLeft(rRange), - begin + bottomRight(rRange), - accessor); - } - - template< class Iterator, class Accessor > - inline vigra::pair - srcIter(Iterator const& begin, - Accessor const& accessor, - const basegfx::B2IPoint& rPt) - { - return vigra::pair( - begin + vigra::Diff2D(rPt.getX(),rPt.getY()), - accessor); - } - - template< class Iterator, class Accessor > - inline vigra::pair - destIter(Iterator const& begin, - Accessor const& accessor, - const basegfx::B2IPoint& rPt) - { - return vigra::pair( - begin + vigra::Diff2D(rPt.getX(),rPt.getY()), - accessor); - } -} - -#endif /* INCLUDED_BASEBMP_TOOLS_HXX */ - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit