Code Duplication - GravityMedia/Ghostscript - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 315-315 lines in 2 locations

src/Devices/DistillerParameters/ColorImageCompressionTrait.php 1 location


 *
 * @package GravityMedia\Ghostscript\Devices\DistillerParameters
 */
trait ColorImageCompressionTrait
{
    /**
     * Available color image downsample type values
     *
     * @var string[]
     */
    protected static $colorImageDownsampleTypeValues = [
        DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_AVERAGE,
        DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_BICUBIC,
        DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_SUBSAMPLE,
        DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_NONE,
    ];

    /**
     * Available color image filter values
     *
     * @var string[]
     */
    protected static $colorImageFilterValues = [
        DistillerParametersInterface::IMAGE_FILTER_DCT_ENCODE,
        DistillerParametersInterface::IMAGE_FILTER_FLATE_ENCODE
    ];

    /**
     * Get argument value
     *
     * @param string $name
     *
     * @return string
     */
    abstract protected function getArgumentValue($name);

    /**
     * Set argument
     *
     * @param string $argument
     *
     * @return $this
     */
    abstract protected function setArgument($argument);

    /**
     * Whether to anti alias color images
     *
     * @return bool
     */
    public function isAntiAliasColorImages()
    {
        $value = $this->getArgumentValue('-dAntiAliasColorImages');
        if (null === $value) {
            return false;
        }

        return filter_var($value, FILTER_VALIDATE_BOOLEAN);
    }

    /**
     * Set anti alias color images flag
     *
     * @param bool $antiAliasColorImages
     *
     * @return $this
     */
    public function setAntiAliasColorImages($antiAliasColorImages)
    {
        $this->setArgument(sprintf('-dAntiAliasColorImages=%s', $antiAliasColorImages ? 'true' : 'false'));

        return $this;
    }

    /**
     * Whether to auto filter color images
     *
     * @return bool
     */
    public function isAutoFilterColorImages()
    {
        $value = $this->getArgumentValue('-dAutoFilterColorImages');
        if (null === $value) {
            return true;
        }

        return filter_var($value, FILTER_VALIDATE_BOOLEAN);
    }

    /**
     * Set auto filter color images flag
     *
     * @param bool $autoFilterColorImages
     *
     * @return $this
     */
    public function setAutoFilterColorImages($autoFilterColorImages)
    {
        $this->setArgument(sprintf('-dAutoFilterColorImages=%s', $autoFilterColorImages ? 'true' : 'false'));

        return $this;
    }

    /**
     * Get color image depth
     *
     * @return int
     */
    public function getColorImageDepth()
    {
        $value = $this->getArgumentValue('-dColorImageDepth');
        if (null === $value) {
            return -1;
        }

        return intval($value);
    }

    /**
     * Set color image depth
     *
     * @param int $colorImageDepth
     *
     * @return $this
     */
    public function setColorImageDepth($colorImageDepth)
    {
        $this->setArgument(sprintf('-dColorImageDepth=%s', $colorImageDepth));

        return $this;
    }

    /**
     * Get color image downsample threshold
     *
     * @return float
     */
    public function getColorImageDownsampleThreshold()
    {
        $value = $this->getArgumentValue('-dColorImageDownsampleThreshold');
        if (null === $value) {
            return 1.5;
        }

        return floatval($value);
    }

    /**
     * Set color image downsample threshold
     *
     * @param float $colorImageDownsampleThreshold
     *
     * @return $this
     */
    public function setColorImageDownsampleThreshold($colorImageDownsampleThreshold)
    {
        $this->setArgument(sprintf('-dColorImageDownsampleThreshold=%s', $colorImageDownsampleThreshold));

        return $this;
    }

    /**
     * Get color image downsample type
     *
     * @return string
     */
    public function getColorImageDownsampleType()
    {
        $value = $this->getArgumentValue('-dColorImageDownsampleType');
        if (null === $value) {
            return DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_SUBSAMPLE;
        }

        return substr($value, 1);
    }

    /**
     * Set color image downsample type
     *
     * @param string $colorImageDownsampleType
     *
     * @throws \InvalidArgumentException
     *
     * @return $this
     */
    public function setColorImageDownsampleType($colorImageDownsampleType)
    {
        if (!in_array($colorImageDownsampleType, static::$colorImageDownsampleTypeValues)) {
            throw new \InvalidArgumentException('Invalid color image downsample type argument');
        }

        $this->setArgument(sprintf('-dColorImageDownsampleType=/%s', $colorImageDownsampleType));

        return $this;
    }

    /**
     * Get color image filter
     *
     * @return string
     */
    public function getColorImageFilter()
    {
        $value = $this->getArgumentValue('-dColorImageFilter');
        if (null === $value) {
            return DistillerParametersInterface::IMAGE_FILTER_DCT_ENCODE;
        }

        return substr($value, 1);
    }

    /**
     * Set color image filter
     *
     * @param string $colorImageFilter
     *
     * @throws \InvalidArgumentException
     *
     * @return $this
     */
    public function setColorImageFilter($colorImageFilter)
    {
        if (!in_array($colorImageFilter, static::$colorImageFilterValues)) {
            throw new \InvalidArgumentException('Invalid color image filter argument');
        }

        $this->setArgument(sprintf('-dColorImageFilter=/%s', $colorImageFilter));

        return $this;
    }

    /**
     * Get color image resolution
     *
     * @return int
     */
    public function getColorImageResolution()
    {
        $value = $this->getArgumentValue('-dColorImageResolution');
        if (null === $value) {
            return 72;
        }

        return intval($value);
    }

    /**
     * Set color image resolution
     *
     * @param int $colorImageResolution
     *
     * @return $this
     */
    public function setColorImageResolution($colorImageResolution)
    {
        $this->setArgument(sprintf('-dColorImageResolution=%s', $colorImageResolution));

        return $this;
    }

    /**
     * Whether to downsample color images
     *
     * @return bool
     */
    public function isDownsampleColorImages()
    {
        $value = $this->getArgumentValue('-dDownsampleColorImages');
        if (null === $value) {
            return false;
        }

        return filter_var($value, FILTER_VALIDATE_BOOLEAN);
    }

    /**
     * Set downsample color images flag
     *
     * @param bool $downsampleColorImages
     *
     * @return $this
     */
    public function setDownsampleColorImages($downsampleColorImages)
    {
        $this->setArgument(sprintf('-dDownsampleColorImages=%s', $downsampleColorImages ? 'true' : 'false'));;

        return $this;
    }

    /**
     * Whether to encode color images
     *
     * @return bool
     */
    public function isEncodeColorImages()
    {
        $value = $this->getArgumentValue('-dEncodeColorImages');
        if (null === $value) {
            return true;
        }

        return filter_var($value, FILTER_VALIDATE_BOOLEAN);
    }

    /**
     * Set encode color images flag
     *
     * @param bool $encodeColorImages
     *
     * @return $this
     */
    public function setEncodeColorImages($encodeColorImages)
    {
        $this->setArgument(sprintf('-dEncodeColorImages=%s', $encodeColorImages ? 'true' : 'false'));

        return $this;
    }
}


src/Devices/DistillerParameters/GrayscaleImageCompressionTrait.php 1 location


 *
 * @package GravityMedia\Ghostscript\Devices\DistillerParameters
 */
trait GrayscaleImageCompressionTrait
{
    /**
     * Available grayscale image downsample type values
     *
     * @var string[]
     */
    protected static $grayImageDownsampleTypeValues = [
        DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_AVERAGE,
        DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_BICUBIC,
        DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_SUBSAMPLE,
        DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_NONE,
    ];

    /**
     * Available grayscale image filter values
     *
     * @var string[]
     */
    protected static $grayImageFilterValues = [
        DistillerParametersInterface::IMAGE_FILTER_DCT_ENCODE,
        DistillerParametersInterface::IMAGE_FILTER_FLATE_ENCODE
    ];

    /**
     * Get argument value
     *
     * @param string $name
     *
     * @return string
     */
    abstract protected function getArgumentValue($name);

    /**
     * Set argument
     *
     * @param string $argument
     *
     * @return $this
     */
    abstract protected function setArgument($argument);

    /**
     * Whether to anti alias grayscale images
     *
     * @return bool
     */
    public function isAntiAliasGrayImages()
    {
        $value = $this->getArgumentValue('-dAntiAliasGrayImages');
        if (null === $value) {
            return false;
        }

        return filter_var($value, FILTER_VALIDATE_BOOLEAN);
    }

    /**
     * Set anti alias grayscale images flag
     *
     * @param bool $antiAliasGrayImages
     *
     * @return $this
     */
    public function setAntiAliasGrayImages($antiAliasGrayImages)
    {
        $this->setArgument(sprintf('-dAntiAliasGrayImages=%s', $antiAliasGrayImages ? 'true' : 'false'));

        return $this;
    }

    /**
     * Whether to auto filter grayscale images
     *
     * @return bool
     */
    public function isAutoFilterGrayImages()
    {
        $value = filter_var($this->getArgumentValue('-dAutoFilterGrayImages'), FILTER_VALIDATE_BOOLEAN);
        if (null === $value) {
            return true;
        }

        return filter_var($value, FILTER_VALIDATE_BOOLEAN);
    }

    /**
     * Set auto filter grayscale images flag
     *
     * @param bool $autoFilterGrayImages
     *
     * @return $this
     */
    public function setAutoFilterGrayImages($autoFilterGrayImages)
    {
        $this->setArgument(sprintf('-dAutoFilterGrayImages=%s', $autoFilterGrayImages ? 'true' : 'false'));

        return $this;
    }

    /**
     * Whether to downsample gray images
     *
     * @return bool
     */
    public function isDownsampleGrayImages()
    {
        $value = $this->getArgumentValue('-dDownsampleGrayImages');
        if (null === $value) {
            return false;
        }

        return filter_var($value, FILTER_VALIDATE_BOOLEAN);
    }

    /**
     * Set downsample gray images flag
     *
     * @param bool $downsampleGrayImages
     *
     * @return $this
     */
    public function setDownsampleGrayImages($downsampleGrayImages)
    {
        $this->setArgument(sprintf('-dDownsampleGrayImages=%s', $downsampleGrayImages ? 'true' : 'false'));

        return $this;
    }

    /**
     * Whether to encode grayscale images
     *
     * @return bool
     */
    public function isEncodeGrayImages()
    {
        $value = $this->getArgumentValue('-dEncodeGrayImages');
        if (null === $value) {
            return true;
        }

        return filter_var($value, FILTER_VALIDATE_BOOLEAN);
    }

    /**
     * Set encode grayscale images flag
     *
     * @param bool $encodeGrayImages
     *
     * @return $this
     */
    public function setEncodeGrayImages($encodeGrayImages)
    {
        $this->setArgument(sprintf('-dEncodeGrayImages=%s', $encodeGrayImages ? 'true' : 'false'));

        return $this;
    }

    /**
     * Get gray image depth
     *
     * @return int
     */
    public function getGrayImageDepth()
    {
        $value = $this->getArgumentValue('-dGrayImageDepth');
        if (null === $value) {
            return -1;
        }

        return intval($value);
    }

    /**
     * Set gray image depth
     *
     * @param int $grayImageDepth
     *
     * @return $this
     */
    public function setGrayImageDepth($grayImageDepth)
    {
        $this->setArgument(sprintf('-dGrayImageDepth=%s', $grayImageDepth));

        return $this;
    }

    /**
     * Get gray image downsample threshold
     *
     * @return float
     */
    public function getGrayImageDownsampleThreshold()
    {
        $value = $this->getArgumentValue('-dGrayImageDownsampleThreshold');
        if (null === $value) {
            return 1.5;
        }

        return floatval($value);
    }

    /**
     * Set gray image downsample threshold
     *
     * @param float $grayImageDownsampleThreshold
     *
     * @return $this
     */
    public function setGrayImageDownsampleThreshold($grayImageDownsampleThreshold)
    {
        $this->setArgument(sprintf('-dGrayImageDownsampleThreshold=%s', $grayImageDownsampleThreshold));

        return $this;
    }

    /**
     * Get gray image downsample type
     *
     * @return string
     */
    public function getGrayImageDownsampleType()
    {
        $value = $this->getArgumentValue('-dGrayImageDownsampleType');
        if (null === $value) {
            return DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_SUBSAMPLE;
        }

        return substr($value, 1);
    }

    /**
     * Set gray image downsample type
     *
     * @param string $grayImageDownsampleType
     *
     * @throws \InvalidArgumentException
     *
     * @return $this
     */
    public function setGrayImageDownsampleType($grayImageDownsampleType)
    {
        if (!in_array($grayImageDownsampleType, static::$grayImageDownsampleTypeValues)) {
            throw new \InvalidArgumentException('Invalid grayscale image downsample type argument');
        }

        $this->setArgument(sprintf('-dGrayImageDownsampleType=/%s', $grayImageDownsampleType));

        return $this;
    }

    /**
     * Get gray image filter
     *
     * @return string
     */
    public function getGrayImageFilter()
    {
        $value = $this->getArgumentValue('-dGrayImageFilter');
        if (null === $value) {
            return DistillerParametersInterface::IMAGE_FILTER_DCT_ENCODE;
        }

        return substr($value, 1);
    }

    /**
     * Set gray image filter
     *
     * @param string $grayImageFilter
     *
     * @throws \InvalidArgumentException
     *
     * @return $this
     */
    public function setGrayImageFilter($grayImageFilter)
    {
        if (!in_array($grayImageFilter, static::$grayImageDownsampleTypeValues)) {
            throw new \InvalidArgumentException('Invalid grayscale image filter argument');
        }

        $this->setArgument(sprintf('-dGrayImageFilter=/%s', $grayImageFilter));

        return $this;
    }

    /**
     * Get gray image resolution
     *
     * @return int
     */
    public function getGrayImageResolution()
    {
        $value = $this->getArgumentValue('-dGrayImageResolution');
        if (null === $value) {
            return 72;
        }

        return intval($value);
    }

    /**
     * Set gray image resolution
     *
     * @param int $grayImageResolution
     *
     * @return $this
     */
    public function setGrayImageResolution($grayImageResolution)
    {
        $this->setArgument(sprintf('-dGrayImageResolution=%s', $grayImageResolution));

        return $this;
    }
}


		@@ 17-331 (lines=315) @@
14		*
15		* @package GravityMedia\Ghostscript\Devices\DistillerParameters
16		*/
17		trait ColorImageCompressionTrait
18		{
19		/**
20		* Available color image downsample type values
21		*
22		* @var string[]
23		*/
24		protected static $colorImageDownsampleTypeValues = [
25		DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_AVERAGE,
26		DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_BICUBIC,
27		DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_SUBSAMPLE,
28		DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_NONE,
29		];
30
31		/**
32		* Available color image filter values
33		*
34		* @var string[]
35		*/
36		protected static $colorImageFilterValues = [
37		DistillerParametersInterface::IMAGE_FILTER_DCT_ENCODE,
38		DistillerParametersInterface::IMAGE_FILTER_FLATE_ENCODE
39		];
40
41		/**
42		* Get argument value
43		*
44		* @param string $name
45		*
46		* @return string
47		*/
48		abstract protected function getArgumentValue($name);
49
50		/**
51		* Set argument
52		*
53		* @param string $argument
54		*
55		* @return $this
56		*/
57		abstract protected function setArgument($argument);
58
59		/**
60		* Whether to anti alias color images
61		*
62		* @return bool
63		*/
64		public function isAntiAliasColorImages()
65		{
66		$value = $this->getArgumentValue('-dAntiAliasColorImages');
67		if (null === $value) {
68		return false;
69		}
70
71		return filter_var($value, FILTER_VALIDATE_BOOLEAN);
72		}
73
74		/**
75		* Set anti alias color images flag
76		*
77		* @param bool $antiAliasColorImages
78		*
79		* @return $this
80		*/
81		public function setAntiAliasColorImages($antiAliasColorImages)
82		{
83		$this->setArgument(sprintf('-dAntiAliasColorImages=%s', $antiAliasColorImages ? 'true' : 'false'));
84
85		return $this;
86		}
87
88		/**
89		* Whether to auto filter color images
90		*
91		* @return bool
92		*/
93		public function isAutoFilterColorImages()
94		{
95		$value = $this->getArgumentValue('-dAutoFilterColorImages');
96		if (null === $value) {
97		return true;
98		}
99
100		return filter_var($value, FILTER_VALIDATE_BOOLEAN);
101		}
102
103		/**
104		* Set auto filter color images flag
105		*
106		* @param bool $autoFilterColorImages
107		*
108		* @return $this
109		*/
110		public function setAutoFilterColorImages($autoFilterColorImages)
111		{
112		$this->setArgument(sprintf('-dAutoFilterColorImages=%s', $autoFilterColorImages ? 'true' : 'false'));
113
114		return $this;
115		}
116
117		/**
118		* Get color image depth
119		*
120		* @return int
121		*/
122		public function getColorImageDepth()
123		{
124		$value = $this->getArgumentValue('-dColorImageDepth');
125		if (null === $value) {
126		return -1;
127		}
128
129		return intval($value);
130		}
131
132		/**
133		* Set color image depth
134		*
135		* @param int $colorImageDepth
136		*
137		* @return $this
138		*/
139		public function setColorImageDepth($colorImageDepth)
140		{
141		$this->setArgument(sprintf('-dColorImageDepth=%s', $colorImageDepth));
142
143		return $this;
144		}
145
146		/**
147		* Get color image downsample threshold
148		*
149		* @return float
150		*/
151		public function getColorImageDownsampleThreshold()
152		{
153		$value = $this->getArgumentValue('-dColorImageDownsampleThreshold');
154		if (null === $value) {
155		return 1.5;
156		}
157
158		return floatval($value);
159		}
160
161		/**
162		* Set color image downsample threshold
163		*
164		* @param float $colorImageDownsampleThreshold
165		*
166		* @return $this
167		*/
168		public function setColorImageDownsampleThreshold($colorImageDownsampleThreshold)
169		{
170		$this->setArgument(sprintf('-dColorImageDownsampleThreshold=%s', $colorImageDownsampleThreshold));
171
172		return $this;
173		}
174
175		/**
176		* Get color image downsample type
177		*
178		* @return string
179		*/
180		public function getColorImageDownsampleType()
181		{
182		$value = $this->getArgumentValue('-dColorImageDownsampleType');
183		if (null === $value) {
184		return DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_SUBSAMPLE;
185		}
186
187		return substr($value, 1);
188		}
189
190		/**
191		* Set color image downsample type
192		*
193		* @param string $colorImageDownsampleType
194		*
195		* @throws \InvalidArgumentException
196		*
197		* @return $this
198		*/
199		public function setColorImageDownsampleType($colorImageDownsampleType)
200		{
201		if (!in_array($colorImageDownsampleType, static::$colorImageDownsampleTypeValues)) {
202		throw new \InvalidArgumentException('Invalid color image downsample type argument');
203		}
204
205		$this->setArgument(sprintf('-dColorImageDownsampleType=/%s', $colorImageDownsampleType));
206
207		return $this;
208		}
209
210		/**
211		* Get color image filter
212		*
213		* @return string
214		*/
215		public function getColorImageFilter()
216		{
217		$value = $this->getArgumentValue('-dColorImageFilter');
218		if (null === $value) {
219		return DistillerParametersInterface::IMAGE_FILTER_DCT_ENCODE;
220		}
221
222		return substr($value, 1);
223		}
224
225		/**
226		* Set color image filter
227		*
228		* @param string $colorImageFilter
229		*
230		* @throws \InvalidArgumentException
231		*
232		* @return $this
233		*/
234		public function setColorImageFilter($colorImageFilter)
235		{
236		if (!in_array($colorImageFilter, static::$colorImageFilterValues)) {
237		throw new \InvalidArgumentException('Invalid color image filter argument');
238		}
239
240		$this->setArgument(sprintf('-dColorImageFilter=/%s', $colorImageFilter));
241
242		return $this;
243		}
244
245		/**
246		* Get color image resolution
247		*
248		* @return int
249		*/
250		public function getColorImageResolution()
251		{
252		$value = $this->getArgumentValue('-dColorImageResolution');
253		if (null === $value) {
254		return 72;
255		}
256
257		return intval($value);
258		}
259
260		/**
261		* Set color image resolution
262		*
263		* @param int $colorImageResolution
264		*
265		* @return $this
266		*/
267		public function setColorImageResolution($colorImageResolution)
268		{
269		$this->setArgument(sprintf('-dColorImageResolution=%s', $colorImageResolution));
270
271		return $this;
272		}
273
274		/**
275		* Whether to downsample color images
276		*
277		* @return bool
278		*/
279		public function isDownsampleColorImages()
280		{
281		$value = $this->getArgumentValue('-dDownsampleColorImages');
282		if (null === $value) {
283		return false;
284		}
285
286		return filter_var($value, FILTER_VALIDATE_BOOLEAN);
287		}
288
289		/**
290		* Set downsample color images flag
291		*
292		* @param bool $downsampleColorImages
293		*
294		* @return $this
295		*/
296		public function setDownsampleColorImages($downsampleColorImages)
297		{
298		$this->setArgument(sprintf('-dDownsampleColorImages=%s', $downsampleColorImages ? 'true' : 'false'));;
299
300		return $this;
301		}
302
303		/**
304		* Whether to encode color images
305		*
306		* @return bool
307		*/
308		public function isEncodeColorImages()
309		{
310		$value = $this->getArgumentValue('-dEncodeColorImages');
311		if (null === $value) {
312		return true;
313		}
314
315		return filter_var($value, FILTER_VALIDATE_BOOLEAN);
316		}
317
318		/**
319		* Set encode color images flag
320		*
321		* @param bool $encodeColorImages
322		*
323		* @return $this
324		*/
325		public function setEncodeColorImages($encodeColorImages)
326		{
327		$this->setArgument(sprintf('-dEncodeColorImages=%s', $encodeColorImages ? 'true' : 'false'));
328
329		return $this;
330		}
331		}
332

		@@ 17-331 (lines=315) @@
14		*
15		* @package GravityMedia\Ghostscript\Devices\DistillerParameters
16		*/
17		trait GrayscaleImageCompressionTrait
18		{
19		/**
20		* Available grayscale image downsample type values
21		*
22		* @var string[]
23		*/
24		protected static $grayImageDownsampleTypeValues = [
25		DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_AVERAGE,
26		DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_BICUBIC,
27		DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_SUBSAMPLE,
28		DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_NONE,
29		];
30
31		/**
32		* Available grayscale image filter values
33		*
34		* @var string[]
35		*/
36		protected static $grayImageFilterValues = [
37		DistillerParametersInterface::IMAGE_FILTER_DCT_ENCODE,
38		DistillerParametersInterface::IMAGE_FILTER_FLATE_ENCODE
39		];
40
41		/**
42		* Get argument value
43		*
44		* @param string $name
45		*
46		* @return string
47		*/
48		abstract protected function getArgumentValue($name);
49
50		/**
51		* Set argument
52		*
53		* @param string $argument
54		*
55		* @return $this
56		*/
57		abstract protected function setArgument($argument);
58
59		/**
60		* Whether to anti alias grayscale images
61		*
62		* @return bool
63		*/
64		public function isAntiAliasGrayImages()
65		{
66		$value = $this->getArgumentValue('-dAntiAliasGrayImages');
67		if (null === $value) {
68		return false;
69		}
70
71		return filter_var($value, FILTER_VALIDATE_BOOLEAN);
72		}
73
74		/**
75		* Set anti alias grayscale images flag
76		*
77		* @param bool $antiAliasGrayImages
78		*
79		* @return $this
80		*/
81		public function setAntiAliasGrayImages($antiAliasGrayImages)
82		{
83		$this->setArgument(sprintf('-dAntiAliasGrayImages=%s', $antiAliasGrayImages ? 'true' : 'false'));
84
85		return $this;
86		}
87
88		/**
89		* Whether to auto filter grayscale images
90		*
91		* @return bool
92		*/
93		public function isAutoFilterGrayImages()
94		{
95		$value = filter_var($this->getArgumentValue('-dAutoFilterGrayImages'), FILTER_VALIDATE_BOOLEAN);
96		if (null === $value) {
97		return true;
98		}
99
100		return filter_var($value, FILTER_VALIDATE_BOOLEAN);
101		}
102
103		/**
104		* Set auto filter grayscale images flag
105		*
106		* @param bool $autoFilterGrayImages
107		*
108		* @return $this
109		*/
110		public function setAutoFilterGrayImages($autoFilterGrayImages)
111		{
112		$this->setArgument(sprintf('-dAutoFilterGrayImages=%s', $autoFilterGrayImages ? 'true' : 'false'));
113
114		return $this;
115		}
116
117		/**
118		* Whether to downsample gray images
119		*
120		* @return bool
121		*/
122		public function isDownsampleGrayImages()
123		{
124		$value = $this->getArgumentValue('-dDownsampleGrayImages');
125		if (null === $value) {
126		return false;
127		}
128
129		return filter_var($value, FILTER_VALIDATE_BOOLEAN);
130		}
131
132		/**
133		* Set downsample gray images flag
134		*
135		* @param bool $downsampleGrayImages
136		*
137		* @return $this
138		*/
139		public function setDownsampleGrayImages($downsampleGrayImages)
140		{
141		$this->setArgument(sprintf('-dDownsampleGrayImages=%s', $downsampleGrayImages ? 'true' : 'false'));
142
143		return $this;
144		}
145
146		/**
147		* Whether to encode grayscale images
148		*
149		* @return bool
150		*/
151		public function isEncodeGrayImages()
152		{
153		$value = $this->getArgumentValue('-dEncodeGrayImages');
154		if (null === $value) {
155		return true;
156		}
157
158		return filter_var($value, FILTER_VALIDATE_BOOLEAN);
159		}
160
161		/**
162		* Set encode grayscale images flag
163		*
164		* @param bool $encodeGrayImages
165		*
166		* @return $this
167		*/
168		public function setEncodeGrayImages($encodeGrayImages)
169		{
170		$this->setArgument(sprintf('-dEncodeGrayImages=%s', $encodeGrayImages ? 'true' : 'false'));
171
172		return $this;
173		}
174
175		/**
176		* Get gray image depth
177		*
178		* @return int
179		*/
180		public function getGrayImageDepth()
181		{
182		$value = $this->getArgumentValue('-dGrayImageDepth');
183		if (null === $value) {
184		return -1;
185		}
186
187		return intval($value);
188		}
189
190		/**
191		* Set gray image depth
192		*
193		* @param int $grayImageDepth
194		*
195		* @return $this
196		*/
197		public function setGrayImageDepth($grayImageDepth)
198		{
199		$this->setArgument(sprintf('-dGrayImageDepth=%s', $grayImageDepth));
200
201		return $this;
202		}
203
204		/**
205		* Get gray image downsample threshold
206		*
207		* @return float
208		*/
209		public function getGrayImageDownsampleThreshold()
210		{
211		$value = $this->getArgumentValue('-dGrayImageDownsampleThreshold');
212		if (null === $value) {
213		return 1.5;
214		}
215
216		return floatval($value);
217		}
218
219		/**
220		* Set gray image downsample threshold
221		*
222		* @param float $grayImageDownsampleThreshold
223		*
224		* @return $this
225		*/
226		public function setGrayImageDownsampleThreshold($grayImageDownsampleThreshold)
227		{
228		$this->setArgument(sprintf('-dGrayImageDownsampleThreshold=%s', $grayImageDownsampleThreshold));
229
230		return $this;
231		}
232
233		/**
234		* Get gray image downsample type
235		*
236		* @return string
237		*/
238		public function getGrayImageDownsampleType()
239		{
240		$value = $this->getArgumentValue('-dGrayImageDownsampleType');
241		if (null === $value) {
242		return DistillerParametersInterface::IMAGE_DOWNSAMPLE_TYPE_SUBSAMPLE;
243		}
244
245		return substr($value, 1);
246		}
247
248		/**
249		* Set gray image downsample type
250		*
251		* @param string $grayImageDownsampleType
252		*
253		* @throws \InvalidArgumentException
254		*
255		* @return $this
256		*/
257		public function setGrayImageDownsampleType($grayImageDownsampleType)
258		{
259		if (!in_array($grayImageDownsampleType, static::$grayImageDownsampleTypeValues)) {
260		throw new \InvalidArgumentException('Invalid grayscale image downsample type argument');
261		}
262
263		$this->setArgument(sprintf('-dGrayImageDownsampleType=/%s', $grayImageDownsampleType));
264
265		return $this;
266		}
267
268		/**
269		* Get gray image filter
270		*
271		* @return string
272		*/
273		public function getGrayImageFilter()
274		{
275		$value = $this->getArgumentValue('-dGrayImageFilter');
276		if (null === $value) {
277		return DistillerParametersInterface::IMAGE_FILTER_DCT_ENCODE;
278		}
279
280		return substr($value, 1);
281		}
282
283		/**
284		* Set gray image filter
285		*
286		* @param string $grayImageFilter
287		*
288		* @throws \InvalidArgumentException
289		*
290		* @return $this
291		*/
292		public function setGrayImageFilter($grayImageFilter)
293		{
294		if (!in_array($grayImageFilter, static::$grayImageDownsampleTypeValues)) {
295		throw new \InvalidArgumentException('Invalid grayscale image filter argument');
296		}
297
298		$this->setArgument(sprintf('-dGrayImageFilter=/%s', $grayImageFilter));
299
300		return $this;
301		}
302
303		/**
304		* Get gray image resolution
305		*
306		* @return int
307		*/
308		public function getGrayImageResolution()
309		{
310		$value = $this->getArgumentValue('-dGrayImageResolution');
311		if (null === $value) {
312		return 72;
313		}
314
315		return intval($value);
316		}
317
318		/**
319		* Set gray image resolution
320		*
321		* @param int $grayImageResolution
322		*
323		* @return $this
324		*/
325		public function setGrayImageResolution($grayImageResolution)
326		{
327		$this->setArgument(sprintf('-dGrayImageResolution=%s', $grayImageResolution));
328
329		return $this;
330		}
331		}
332

GravityMedia / Ghostscript

Code Duplication Length = 315-315 lines in 2 locations

src/Devices/DistillerParameters/ColorImageCompressionTrait.php 1 location

src/Devices/DistillerParameters/GrayscaleImageCompressionTrait.php 1 location