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

Code Duplication Length = 325-325 lines in 2 locations

src/Device/DistillerParameters/ColorImageCompressionTrait.php 1 location


 *
 * @package GravityMedia\Ghostscript\Device\DistillerParameters
 */
trait ColorImageCompressionTrait
{
    /**
     * Get argument value
     *
     * @param string $name
     *
     * @return null|string
     */
    abstract protected function getArgumentValue($name);

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

    /**
     * Get PDF settings
     *
     * @return string
     */
    abstract public function getPdfSettings();

    /**
     * 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) {
            switch ($this->getPdfSettings()) {
                case PdfSettings::SCREEN:
                case PdfSettings::EBOOK:
                case PdfSettings::PRINTER:
                    return ImageDownsampleType::AVERAGE;
                case PdfSettings::PREPRESS:
                    return ImageDownsampleType::BICUBIC;
                default:
                    return ImageDownsampleType::SUBSAMPLE;
            }
        }

        return ltrim($value, '/');
    }

    /**
     * Set color image downsample type
     *
     * @param string $colorImageDownsampleType
     *
     * @throws \InvalidArgumentException
     *
     * @return $this
     */
    public function setColorImageDownsampleType($colorImageDownsampleType)
    {
        $colorImageDownsampleType = ltrim($colorImageDownsampleType, '/');
        if (!in_array($colorImageDownsampleType, ImageDownsampleType::values())) {
            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 ColorAndGrayImageFilter::DCT_ENCODE;
        }

        return ltrim($value, '/');
    }

    /**
     * Set color image filter
     *
     * @param string $colorImageFilter
     *
     * @throws \InvalidArgumentException
     *
     * @return $this
     */
    public function setColorImageFilter($colorImageFilter)
    {
        $colorImageFilter = ltrim($colorImageFilter, '/');
        if (!in_array($colorImageFilter, ColorAndGrayImageFilter::values())) {
            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) {
            switch ($this->getPdfSettings()) {
                case PdfSettings::EBOOK:
                    return 150;
                case PdfSettings::PRINTER:
                case PdfSettings::PREPRESS:
                    return 300;
                default:
                    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) {
            switch ($this->getPdfSettings()) {
                case PdfSettings::SCREEN:
                case PdfSettings::EBOOK:
                    return true;
                default:
                    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/Device/DistillerParameters/GrayImageCompressionTrait.php 1 location


 *
 * @package GravityMedia\Ghostscript\Device\DistillerParameters
 */
trait GrayImageCompressionTrait
{
    /**
     * Get argument value
     *
     * @param string $name
     *
     * @return null|string
     */
    abstract protected function getArgumentValue($name);

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

    /**
     * Get PDF settings
     *
     * @return string
     */
    abstract public function getPdfSettings();

    /**
     * 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 = $this->getArgumentValue('-dAutoFilterGrayImages');
        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) {
            switch ($this->getPdfSettings()) {
                case PdfSettings::SCREEN:
                case PdfSettings::EBOOK:
                    return true;
                default:
                    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) {
            switch ($this->getPdfSettings()) {
                case PdfSettings::SCREEN:
                    return ImageDownsampleType::AVERAGE;
                case PdfSettings::EBOOK:
                case PdfSettings::PRINTER:
                case PdfSettings::PREPRESS:
                    return ImageDownsampleType::BICUBIC;
                default:
                    return ImageDownsampleType::SUBSAMPLE;
            }
        }

        return ltrim($value, '/');
    }

    /**
     * Set gray image downsample type
     *
     * @param string $grayImageDownsampleType
     *
     * @throws \InvalidArgumentException
     *
     * @return $this
     */
    public function setGrayImageDownsampleType($grayImageDownsampleType)
    {
        $grayImageDownsampleType = ltrim($grayImageDownsampleType, '/');
        if (!in_array($grayImageDownsampleType, ImageDownsampleType::values())) {
            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 ColorAndGrayImageFilter::DCT_ENCODE;
        }

        return ltrim($value, '/');
    }

    /**
     * Set gray image filter
     *
     * @param string $grayImageFilter
     *
     * @throws \InvalidArgumentException
     *
     * @return $this
     */
    public function setGrayImageFilter($grayImageFilter)
    {
        $grayImageFilter = ltrim($grayImageFilter, '/');
        if (!in_array($grayImageFilter, ColorAndGrayImageFilter::values())) {
            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) {
            switch ($this->getPdfSettings()) {
                case PdfSettings::EBOOK:
                    return 150;
                case PdfSettings::PRINTER:
                case PdfSettings::PREPRESS:
                    return 300;
                default:
                    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;
    }
}


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

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

GravityMedia / Ghostscript

Code Duplication Length = 325-325 lines in 2 locations

src/Device/DistillerParameters/ColorImageCompressionTrait.php 1 location

src/Device/DistillerParameters/GrayImageCompressionTrait.php 1 location