Passed
Push — master ( c0a3a7...3b84a4 )
by Jeroen
58:51
created

ImageService::normalizeResizeParameters()   C

Complexity

Conditions 19
Paths 77

Size

Total Lines 73
Code Lines 44

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 39
CRAP Score 19.0418

Importance

Changes 0
Metric Value
cc 19
eloc 44
nc 77
nop 3
dl 0
loc 73
ccs 39
cts 41
cp 0.9512
crap 19.0418
rs 5.3851
c 0
b 0
f 0

How to fix   Long Method    Complexity   

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

1
<?php
2
3
namespace Elgg;
4
5
use Exception;
6
use Imagine\Image\Box;
7
use Imagine\Image\ImagineInterface;
8
use Imagine\Image\Point;
9
use Imagine\Filter\Basic\Autorotate;
10
use Elgg\Filesystem\MimeTypeDetector;
11
12
/**
13
 * Image manipulation service
14
 *
15
 * @since 2.3
16
 * @access private
17
 */
18
class ImageService {
19
	use Loggable;
20
21
	const JPEG_QUALITY = 75;
22
23
	/**
24
	 * @var ImagineInterface
25
	 */
26
	private $imagine;
27
28
	/**
29
	 * @var Config
30
	 */
31
	private $config;
32
33
	/**
34
	 * Constructor
35
	 *
36
	 * @param ImagineInterface $imagine Imagine interface
37
	 * @param Config           $config  Elgg config
38
	 */
39 72
	public function __construct(ImagineInterface $imagine, Config $config) {
40 72
		$this->imagine = $imagine;
41 72
		$this->config = $config;
42 72
	}
43
44
	/**
45
	 * Crop and resize an image
46
	 *
47
	 * @param string $source      Path to source image
48
	 * @param string $destination Path to destination
49
	 *                            If not set, will modify the source image
50
	 * @param array  $params      An array of cropping/resizing parameters
51
	 *                             - INT 'w' represents the width of the new image
52
	 *                               With upscaling disabled, this is the maximum width
53
	 *                               of the new image (in case the source image is
54
	 *                               smaller than the expected width)
55
	 *                             - INT 'h' represents the height of the new image
56
	 *                               With upscaling disabled, this is the maximum height
57
	 *                             - INT 'x1', 'y1', 'x2', 'y2' represent optional cropping
58
	 *                               coordinates. The source image will first be cropped
59
	 *                               to these coordinates, and then resized to match
60
	 *                               width/height parameters
61
	 *                             - BOOL 'square' - square images will fill the
62
	 *                               bounding box (width x height). In Imagine's terms,
63
	 *                               this equates to OUTBOUND mode
64
	 *                             - BOOL 'upscale' - if enabled, smaller images
65
	 *                               will be upscaled to fit the bounding box.
66
	 * @return bool
67
	 */
68 47
	public function resize($source, $destination = null, array $params = []) {
69
70 47
		if (!isset($destination)) {
71
			$destination = $source;
72
		}
73
74
		try {
75 47
			$image = $this->imagine->open($source);
76
77 47
			$width = $image->getSize()->getWidth();
78 47
			$height = $image->getSize()->getHeight();
79
80 47
			$resize_params = $this->normalizeResizeParameters($width, $height, $params);
81
82 47
			$max_width = elgg_extract('w', $resize_params);
83 47
			$max_height = elgg_extract('h', $resize_params);
84
85 47
			$x1 = (int) elgg_extract('x1', $resize_params, 0);
86 47
			$y1 = (int) elgg_extract('y1', $resize_params, 0);
87 47
			$x2 = (int) elgg_extract('x2', $resize_params, 0);
88 47
			$y2 = (int) elgg_extract('y2', $resize_params, 0);
89
90 47
			if ($x2 > $x1 && $y2 > $y1) {
91 47
				$crop_start = new Point($x1, $y1);
92 47
				$crop_size = new Box($x2 - $x1, $y2 - $y1);
93 47
				$image->crop($crop_start, $crop_size);
94
			}
95
96 47
			$target_size = new Box($max_width, $max_height);
97 47
			$thumbnail = $image->resize($target_size);
98
99 47
			$thumbnail->save($destination, [
100 47
				'jpeg_quality' => elgg_extract('jpeg_quality', $params, self::JPEG_QUALITY),
101 47
				'format' => $this->getFileFormat($source, $params),
102
			]);
103
104 47
			unset($image);
105 47
			unset($thumbnail);
106
		} catch (Exception $ex) {
107
			$logger = $this->logger ? $this->logger : _elgg_services()->logger;
108
			$logger->error($ex->getMessage());
109
			return false;
110
		}
111
112 47
		return true;
113
	}
114
	
115
	/**
116
	 * If needed the image will be rotated based on orientation information
117
	 *
118
	 * @param string $filename Path to image
119
	 *
120
	 * @return bool
121
	 */
122 5
	function fixOrientation($filename) {
0 ignored issues
show
Best Practice introduced by Jeroen Dalsem
It is generally recommended to explicitly declare the visibility for methods.

Adding explicit visibility (private, protected, or public) is generally recommend to communicate to other developers how, and from where this method is intended to be used.

Loading history...
123
		try {
124 5
			$image = $this->imagine->open($filename);
125 5
			$metadata = $image->metadata();
126 5
			if (!isset($metadata['ifd0.Orientation'])) {
127
				// no need to perform an orientation fix
128 5
				return true;
129
			}
130
			
131
			$autorotate = new Autorotate();
132
			$autorotate->apply($image)->save($filename);
133
			return true;
134
		} catch (Exception $ex) {
135
			$logger = $this->logger ? $this->logger : _elgg_services()->logger;
136
			$logger->notice($ex->getMessage());
137
		}
138
		return false;
139
	}
140
141
	/**
142
	 * Calculate the parameters for resizing an image
143
	 *
144
	 * @param int   $width  Natural width of the image
145
	 * @param int   $height Natural height of the image
146
	 * @param array $params Resize parameters
147
	 *                      - 'w' maximum width of the resized image
148
	 *                      - 'h' maximum height of the resized image
149
	 *                      - 'upscale' allow upscaling
150
	 *                      - 'square' constrain to a square
151
	 *                      - 'x1', 'y1', 'x2', 'y2' cropping coordinates
152
	 *
153
	 * @return array
154
	 * @throws \LogicException
155
	 */
156 48
	public function normalizeResizeParameters($width, $height, array $params = []) {
157
158 48
		$max_width = (int) elgg_extract('w', $params, 100, false);
159 48
		$max_height = (int) elgg_extract('h', $params, 100, false);
160 48
		if (!$max_height || !$max_width) {
161
			throw new \LogicException("Resize width and height parameters are required");
162
		}
163
164 48
		$square = elgg_extract('square', $params, false);
165 48
		$upscale = elgg_extract('upscale', $params, false);
166
167 48
		$x1 = (int) elgg_extract('x1', $params, 0);
168 48
		$y1 = (int) elgg_extract('y1', $params, 0);
169 48
		$x2 = (int) elgg_extract('x2', $params, 0);
170 48
		$y2 = (int) elgg_extract('y2', $params, 0);
171
172 48
		$cropping_mode = $x1 || $y1 || $x2 || $y2;
173
174 48
		if ($cropping_mode) {
175 8
			$crop_width = $x2 - $x1;
176 8
			$crop_height = $y2 - $y1;
177 8
			if ($crop_width <= 0 || $crop_height <= 0 || $crop_width > $width || $crop_height > $height) {
178 8
				throw new \LogicException("Coordinates [$x1, $y1], [$x2, $y2] are invalid for image cropping");
179
			}
180
		} else {
181
			// everything selected if no crop parameters
182 47
			$crop_width = $width;
183 47
			$crop_height = $height;
184
		}
185
186
		// determine cropping offsets
187 48
		if ($square) {
188
			// asking for a square image back
189
			// detect case where someone is passing crop parameters that are not for a square
190 40
			if ($cropping_mode == true && $crop_width != $crop_height) {
0 ignored issues
show
Coding Style Best Practice introduced by Ismayil Khayredinov
It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

When comparing two booleans, it is generally considered safer to use the strict comparison operator.

Loading history...
191
				throw new \LogicException("Coordinates [$x1, $y1], [$x2, $y2] are invalid for a squared image cropping");
192
			}
193
194
			// size of the new square image
195 40
			$max_width = $max_height = min($max_width, $max_height);
196
197
			// find largest square that fits within the selected region
198 40
			$crop_width = $crop_height = min($crop_width, $crop_height);
199
200 40
			if (!$cropping_mode) {
201
				// place square region in the center
202 39
				$x1 = floor(($width - $crop_width) / 2);
203 40
				$y1 = floor(($height - $crop_height) / 2);
204
			}
205
		} else {
206
			// maintain aspect ratio of original image/crop
207 44
			if ($crop_height / $max_height > $crop_width / $max_width) {
208 20
				$max_width = floor($max_height * $crop_width / $crop_height);
209
			} else {
210 26
				$max_height = floor($max_width * $crop_height / $crop_width);
211
			}
212
		}
213
214 48
		if (!$upscale && ($crop_height < $max_height || $crop_width < $max_width)) {
215
			// we cannot upscale and selected area is too small so we decrease size of returned image
216 45
			$max_height = $crop_height;
217 45
			$max_width = $crop_width;
218
		}
219
220
		return [
221 48
			'w' => $max_width,
222 48
			'h' => $max_height,
223 48
			'x1' => $x1,
224 48
			'y1' => $y1,
225 48
			'x2' => $x1 + $crop_width,
226 48
			'y2' => $y1 + $crop_height,
227 48
			'square' => $square,
228 48
			'upscale' => $upscale,
229
		];
230
	}
231
232
	/**
233
	 * Determine the image file format, this is needed for correct resizing
234
	 *
235
	 * @param string $filename path to the file
236
	 * @param array  $params   array of resizing params (can contain 'format' to set save format)
237
	 *
238
	 * @see https://github.com/Elgg/Elgg/issues/10686
239
	 * @return void|string
240
	 */
241 47
	protected function getFileFormat($filename, $params) {
242
		
243
		$accepted_formats = [
244 47
			'image/jpeg' => 'jpeg',
245
			'image/pjpeg' => 'jpeg',
246
			'image/png' => 'png',
247
			'image/x-png' => 'png',
248
			'image/gif' => 'gif',
249
			'image/vnd.wap.wbmp' => 'wbmp',
250
			'image/x‑xbitmap' => 'xbm',
251
			'image/x‑xbm' => 'xbm',
252
		];
253
		
254
		// was a valid output format supplied
255 47
		$format = elgg_extract('format', $params);
256 47
		if (in_array($format, $accepted_formats)) {
257
			return $format;
258
		}
259
		
260 47
		$mime_detector = new MimeTypeDetector();
261 47
		$mime = $mime_detector->getType($filename);
262
		
263 47
		return elgg_extract($mime, $accepted_formats);
264
	}
265
}
266