<h2 id="introduction">Introduction</h2>
Object detection has been gaining steam, and improvements are being made to several approaches to solving it. In the past couple of years, YOLO-based methods have been outperforming others in terms of accuracy and speed, with recent advancements such as YOLOv7 and YOLOv6 (which was released independently, after YOLOv7).
However - all of these are concerning 2D object detection, which is a difficult task in and of itself. Recently, we've been able to successfully perform 3D object detection, and while these detectors are still at a more unstable stage than 2D object detectors, their accuracy is rising.
<blockquote>
In this guide, we'll be performing 3D object detection in Python with MediaPipe's Objectron.
</blockquote>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: MediaPipe is Google's open source framework for building machine learning pipelines to process images, videos and audio streams, primarily for mobile devices. It's being used both internally and externally, and provides pre-trained models for various tasks, such as face detection, face meshing, hand and pose estimation, hair segmentation, object detection, box tracking, etc.

 </div>
 </div>
 </div>
 All of these can and are used for downstream tasks - such as applying filters to faces, automated camera focusing, biometric verification, hand-controlled robotics, etc. Most projects are available with APIs for Android, iOS, C++, Python and JavaScript, while some are only available for certain languages.
In this guide, we'll be working with MediaPipe's Objectron, available for Android, C++, Python and JavaScript.
<h2 id="mediapipeand3dobjectdetection">MediaPipe and 3D Object Detection</h2>
The Objectron solution was trained on the <a rel="nofollow noopener noreferrer" target="_blank" href="https://github.com/google-research-datasets/Objectron">Objectron Dataset</a>, which contains short object-centric videos. The dataset only contains 9 objects: bikes, books, bottles, cameras, cereal boxes, chairs, cups, laptops and shoes, so it's not a very general dataset, but the processing and procurement of these videos is fairly expensive (camera poses, sparse point-clouds, characterization of the planar surfaces, etc. for each frame of each video), making the dataset nearly 2 terabytes in size.
The trained Objectron model (known as a solution for MediaPipe projects) is trained on four categories - shoes, chairs, mugs and cameras.
2D object detection uses the term &quot;bounding boxes&quot;, while they're actually rectangles. 3D object detection actually predicts boxes around objects, from which you can infer their orientation, size, rough volume, etc. This is a fairly difficult task to take on, especially given the lack of appropriate datasets and the cost of creating them. While difficult, the problem holds promise for various Augmented Reality (AR) applications!
The Objectron solution can run in a one-stage or two-stage mode - where the one-stage mode is better at detecting multiple objects, while the two-stage mode is better at detecting a single main object in the scene, and runs significantly faster. The single-stage pipeline uses a MobileNetV2 backbone, while the two-stage pipeline uses the TensorFlow Object Detection API.
When an object is detected in a video, further predictions aren't made for it on each frame for two reasons:
<ul>
<li>Continuous predictions introduce high jitteriness (due to the inherent stochasticity in the predictions)</li>
<li>It's expensive to run large models on every frame</li>
</ul>
The team offloads the heavy predictions to first encounters only and then tracks that box as long as the object in question is still in the scene. Once the line of sight is broken and the object is re-introduced, a prediction is made again. This makes it possible to use larger models with higher accuracy, while keeping the computational requirements low, and lowers the hardware requirements for real-time inference!
Let's go ahead and install MediaPipe, import the Objectron solution and apply it to static images and a video feed coming straight from a camera.
<h2 id="installingmediapipe">Installing MediaPipe</h2>
Let's first install MediaPipe and prepare a helper method to fetch images from a given URL:
<pre><code class="hljs">$ ! pip install mediapipe
</code></pre>
With the framework installed, let's import it alongside common libraries:
<pre><code class="hljs">import mediapipe as mp

import cv2
import numpy as np
import matplotlib.pyplot as plt
</code></pre>
Let's define a helper method to fetch images given a URL and which returns an RGB array representing that image:
<pre><code class="hljs">import PIL
import urllib

def url_to_array(url):
 req = urllib.request.urlopen(url)
 arr = np.array(bytearray(req.read()), dtype=np.int8)
 arr = cv2.imdecode(arr, -1)
 arr = cv2.cvtColor(arr, cv2.COLOR_BGR2RGB)
 return arr

mug = &#x27;https://goodstock.photos/wp-content/uploads/2018/01/Laptop-Coffee-Mug-on-Table.jpg&#x27;
mug = url_to_array(mug)
</code></pre>
Finally, we'll want to import both the Objectron solution and the drawing utilities to visualize predictions:
<pre><code class="hljs">mp_objectron = mp.solutions.objectron
mp_drawing = mp.solutions.drawing_utils
</code></pre>
<h2 id="3dobjectdetectiononstaticimageswithmediapipe">3D Object Detection on Static Images with MediaPipe</h2>
The <code>Objectron</code> class allows for several arguments, including:
<ul>
<li><code>static_image_mode</code>: Whether you're feeding in an image or a stream of images (video)</li>
<li><code>max_num_objects</code>: The maximum identifiable number of objects</li>
<li><code>min_detection_confidence</code>: The detection confidence threshold (how sure the network has to be to classify an object for the given class)</li>
<li><code>model_name</code>: Which model you'd like to load in between <code>'Cup'</code>, <code>'Shoe'</code>, <code>'Camera'</code> and <code>'Chair'</code>.</li>
</ul>
With those in mind - let's instantiate an Objectron instance and <code>process()</code> the input image:
<pre><code class="hljs"># Instantiation
objectron = mp_objectron.Objectron(
 static_image_mode=True,
 max_num_objects=5,
 min_detection_confidence=0.2,
 model_name=&#x27;Cup&#x27;)

# Inference
results = objectron.process(mug)
</code></pre>
The <code>results</code> contain the 2D and 3D landmarks of the detected object(s) as well as the rotation, translation and scale for each. We can process the results and draw the bounding boxes fairly easily using the provided drawing <code>utils</code>:
<pre><code class="hljs">if not results.detected_objects:
 print(f&#x27;No box landmarks detected.&#x27;)

# Copy image so as not to draw on the original one
annotated_image = mug.copy()
for detected_object in results.detected_objects:
 # Draw landmarks
 mp_drawing.draw_landmarks(annotated_image, 
 detected_object.landmarks_2d, 
 mp_objectron.BOX_CONNECTIONS)

 # Draw axis based on rotation and translation
 mp_drawing.draw_axis(annotated_image, 
 detected_object.rotation, 
 detected_object.translation)
 
# Plot result
fig, ax = plt.subplots(figsize=(10, 10))
ax.imshow(annotated_image)
ax.axis(&#x27;off&#x27;)
plt.show()
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/articles/3d-object-detection-3d-bounding-boxes-in-python-with-mediapipe-objectron-0.png" alt="">
<h2 id="3dobjectdetectionfromvideoorwebcamwithmediapipe">3D Object Detection from Video or Web-cam with MediaPipe</h2>
A more exciting application is on videos! You don't have to change the code much to accommodate videos, whether you're providing one from the web-cam or an existing video file. OpenCV is a natural fit for reading, manipulating and feeding video frames into the objectron model:
<pre><code class="hljs"># VideoCapture(0) tries to capture from the webcam
cap = cv2.VideoCapture(0)
# Or
# cap = cv2.VideoCapture(&#x27;filename.mp4&#x27;)

objectron = mp_objectron.Objectron(static_image_mode=False,
 max_num_objects=5,
 min_detection_confidence=0.4,
 min_tracking_confidence=0.70,
 model_name=&#x27;Cup&#x27;)
 
# Read video stream and feed into the model
while cap.isOpened():
 success, image = cap.read()

 image.flags.writeable = False
 image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
 results = objectron.process(image)

 image.flags.writeable = True
 image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
 if results.detected_objects:
 for detected_object in results.detected_objects:
 
 mp_drawing.draw_landmarks(image, 
 detected_object.landmarks_2d, 
 mp_objectron.BOX_CONNECTIONS)
 
 mp_drawing.draw_axis(image, 
 detected_object.rotation,
 detected_object.translation)

 cv2.imshow(&#x27;MediaPipe Objectron&#x27;, cv2.flip(image, 1))
 if cv2.waitKey(10) &amp; 0xFF == ord(&#x27;q&#x27;):
 break
cap.release()
cv2.destroyAllWindows()
</code></pre>
Making the image non-writable with <code>image.flags.writeable = False</code> makes the process run somewhat faster, and is an optional change. The final <code>cv2.flip()</code> on the resulting image is also optional - and simply makes the output mirrored to make it a bit more intuitive.
When run on a camera and a globally common IKEA mug, these are the results:
<img src="https://s3.stackabuse.com/media/articles/3d-object-detection-3d-bounding-boxes-in-python-with-mediapipe-objectron-1.gif" alt="">
The output is slightly jittery, but handles rotational translation well, even with a shaky hand holding the low-resolution camera. What happens when an object is taken out of the frame?
<img src="https://s3.stackabuse.com/media/articles/3d-object-detection-3d-bounding-boxes-in-python-with-mediapipe-objectron-2.gif" alt="">
The predictions stop for the object at the first detection, and box tracking clearly picks up that the object has left the frame, and performs the prediction and tracking once again as soon as the object re-enters the frame. It appears that the tracking works somewhat better when the model can see the mug handle, as the outputs are more jittery when the handle is not visible (presumably because it's harder to accurately ascertain the true orientation of the mug).
Additionally, some angles seem to produce significantly more stable outputs than others, in challenging light conditions. For mugs specifically, it helps to be able to see the lip of the mug as it helps with perspective, rather than seeing an orthogonal projection of the object.
Additionally, when tested on a transparent mug, the model had difficulties ascertaining it as a mug. This is likely an example of an out of distribution object, as most mugs are opaque and have various colors.
<h2 id="conclusion">Conclusion</h2>
3D object detection is still somewhat young, and MediaPipe's Objectron is a capable demonstration! While sensitive to lighting conditions, object types (transparent vs opaque mugs, etc.) and slightly jittery - Objectron is a good glimpse into what will soon be possible to do with higher accuracy and accessibility than ever before.

David Landup

In this practical guide, learn how to perform 3D object detection (regress 3D bounding boxes) around objects in real-time with Python, OpenCV and MediaPipe, built on top of TensorFlow Object Detection.

3D Object Detection (3D Bounding Boxes) in Python with MediaPipe Objectron

<h2 id="introduction">Introduction</h2>
Object detection is a large field in computer vision, and one of the more important applications of computer vision &quot;in the wild&quot;. From it, keypoint detection (oftentimes used for pose estimation) was extracted.
Keypoints can be various points - parts of a face, limbs of a body, etc. Pose estimation is a special case of keypoint detection - in which the points are parts of a human body.
Pose estimation is an amazing, extremely fun and practical usage of computer vision. With it, we can do away with hardware used to estimate poses (motion capture suits), which are costly and unwieldy. Additionally, we can map the movement of humans to the movement of robots in Euclidean space, enabling fine precision motor movement without using controllers, which usually don't allow for higher levels of precision. Keypoint estimation can be used to translate our movements to 3D models in AR and VR, and increasingly is being used to do so with just a web cam. Finally - pose estimation can help us in sports and security.
<blockquote>
In this guide, we'll be performing real-time pose estimation from a video in Python, using the state-of-the-art YOLOv7 model.
</blockquote>
Specifically, we'll be working with a video from the 2018 winter Olympics, held in South Korea's PyeongChang:
<img src="https://s3.stackabuse.com/media/articles/real-time-pose-estimation-from-video-in-python-with-yolov7.gif" alt="">
Aljona Savchenko and Bruno Massot did an amazing performance, including overlapping bodies against the camera, fast fluid movement and spinning in the air. It'll be an amazing opportunity to see how the model handles difficult-to-infer situations!
<h2 id="yoloandposeestimation">YOLO and Pose Estimation</h2>
YOLO (You Only Look Once) is a methodology, as well as a family of models built for object detection. Since the inception in 2015, YOLOv1, YOLOv2 (YOLO9000) and YOLOv3 have been proposed by the same author(s) - and the deep learning community continued with open-sourced advancements in the continuing years.
<a target="_blank" rel="nofollow noopener noreferrer" href="https://github.com/ultralytics/yolov5">Ultralytics' YOLOv5</a> is an industry-grade object detection repository, built on top of the YOLO method. It's implemented in PyTorch, as opposed to C++ for previous YOLO models, is fully open source, and has a beautifully simple and powerful API that lets you infer, train and customize the project flexibly. It's such a staple that most new attempts at improving the YOLO method build on top of it.
This is how <a rel="nofollow noopener noreferrer" target="_blank" href="https://arxiv.org/abs/2105.04206">YOLOR (You Only Learn One Representation)</a> and YOLOv7 which built on top of YOLOR (same author) were created as well!
YOLOv7 isn't just an object detection architecture - it provides new model heads that can output keypoints (skeletons) and perform instance segmentation besides only bounding box regression, which wasn't standard with previous YOLO models. This isn't surprising, since many object detection architectures were re-purposed for instance segmentation and keypoint detection tasks earlier as well, due to the shared general architecture, with different outputs depending on the task.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: If you're interested in reading more about instance segmentation, read our <a target="_blank" href="https://stackabuse.com/instance-segmentation-with-yolov7-in-python/">&quot;Instance Segmentation with YOLOv7 in Python&quot;</a>!

 </div>
 </div>
 </div>
 Even though it isn't surprising - supporting instance segmentation and keypoint detection will likely become the new standard for YOLO-based models, which have begun outperforming practically all other two-stage detectors a couple of years ago in terms of both accuracy and speed.
<blockquote>
This makes instance segmentation and keypoint detection faster to perform than ever before, with a simpler architecture than two-stage detectors.
</blockquote>

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 YOLOv7 was released alongside a paper named <a rel="nofollow noopener noreferrer" target="_blank" href="https://arxiv.org/abs/2207.02696">&quot;YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors&quot;</a>, and the source code is available <a rel="nofollow noopener noreferrer" target="_blank" href="https://github.com/WongKinYiu/yolov7">on GitHub</a>.

 </div>
 </div>
 </div>
 The model itself was created through architectural changes, as well as optimizing aspects of training, dubbed &quot;bag-of-freebies&quot;, which increased accuracy without increasing inference cost.
<h2 id="installingyolov7">Installing YOLOv7</h2>
Let's start by cloning the repository to get hold of the source code:
<pre><code class="hljs">! git clone https://github.com/WongKinYiu/yolov7.git
</code></pre>
Now, let's move into the <code>yolov7</code> directory, which contains the project, and take a look at the contents:
<pre><code class="hljs">%cd yolov7
!ls
</code></pre>
<pre><code class="hljs">/content/yolov7
cfg	 figure output.mp4	 test.py 
data	 hubconf.py paper		 tools
deploy	 inference README.md	 train_aux.py
detect.py LICENSE.md requirements.txt train.py
export.py models scripts		 utils
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Calling <code>!cd dirname</code> moves you into a directory in that cell. Calling <code>%cd dirname</code> moves you into a directory across the upcoming cells as well and keeps you there.

 </div>
 </div>
 </div>
 Now, YOLO is meant to be an object detector, and doesn't ship with pose estimation weights by default. We'll want to download the weights and load a concrete model instance from them. The weights are available on the same GitHub repository, and can easily be downloaded through the CLI as well:
<pre><code class="hljs">! curl -L https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6-pose.pt -o yolov7-w6-pose.pt

 % Total % Received % Xferd Average Speed Time Time Time Current
 Dload Upload Total Spent Left Speed
 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0
100 153M 100 153M 0 0 23.4M 0 0:00:06 0:00:06 --:--:-- 32.3M
</code></pre>
Once downloaded, we can import the libraries and helper methods we'll be using:
<pre><code class="hljs">import torch
from torchvision import transforms

from utils.datasets import letterbox
from utils.general import non_max_suppression_kpt
from utils.plots import output_to_keypoint, plot_skeleton_kpts

import matplotlib.pyplot as plt
import cv2
import numpy as np
</code></pre>
Great! Let's get on with loading the model and creating a script that lets you infer poses from videos with YOLOv7 and OpenCV.
<h2 id="realtimeposeestimationwithyolov7">Real-Time Pose Estimation with YOLOv7</h2>
Let's first create a method to load the model from the downloaded weights. We'll check what device we have available (CPU or GPU):
<pre><code class="hljs">device = torch.device(&quot;cuda:0&quot; if torch.cuda.is_available() else &quot;cpu&quot;)

def load_model():
 model = torch.load(&#x27;yolov7-w6-pose.pt&#x27;, map_location=device)[&#x27;model&#x27;]
 # Put in inference mode
 model.float().eval()

 if torch.cuda.is_available():
 # half() turns predictions into float16 tensors
 # which significantly lowers inference time
 model.half().to(device)
 return model

model = load_model()
</code></pre>
Depending on whether we have a GPU or not, we'll turn half-precision on (using <code>float16</code> instead of <code>float32</code> in operations), which makes inference significantly faster. Note that it's highly encouraged to perform this on a GPU for real-time speeds, as CPUs will likely lack the power to do so unless running on small videos.
Let's write a convenient method for running inference. We'll accept images as NumPy arrays (as that's what we'll be passing them later while reading the video). First, using the <code>letterbox()</code> function - we'll resize and pad the video to a shape that the model can work with. This doesn't need to be and won't be the shape (resolution) of the resulting video!
Then, we'll apply the transforms, convert the image to half precision (if a GPU is available), batch it and run it through the model:
<pre><code class="hljs">def run_inference(image):
 # Resize and pad image
 image = letterbox(image, 960, stride=64, auto=True)[0] # shape: (567, 960, 3)
 # Apply transforms
 image = transforms.ToTensor()(image) # torch.Size([3, 567, 960])
 if torch.cuda.is_available():
 image = image.half().to(device)
 # Turn image into batch
 image = image.unsqueeze(0) # torch.Size([1, 3, 567, 960])
 with torch.no_grad():
 output, _ = model(image)
 return output, image
</code></pre>
We'll return the predictions of the model, as well as the image as a tensor. These are &quot;rough&quot; predictions - they contain many activations that overlap, and we'll want to &quot;clean them up&quot; using Non-Max Suppression, and plot the predicted skeletons over the image itself:
<pre><code class="hljs">def draw_keypoints(output, image):
 output = non_max_suppression_kpt(output, 
 0.25, # Confidence Threshold
 0.65, # IoU Threshold
 nc=model.yaml[&#x27;nc&#x27;], # Number of Classes
 nkpt=model.yaml[&#x27;nkpt&#x27;], # Number of Keypoints
 kpt_label=True)
 with torch.no_grad():
 output = output_to_keypoint(output)
 nimg = image[0].permute(1, 2, 0) * 255
 nimg = nimg.cpu().numpy().astype(np.uint8)
 nimg = cv2.cvtColor(nimg, cv2.COLOR_RGB2BGR)
 for idx in range(output.shape[0]):
 plot_skeleton_kpts(nimg, output[idx, 7:].T, 3)

 return nimg
</code></pre>
With these in place, our general flow will look like:
<pre><code class="hljs">img = read_img()
outputs, img = run_inference(img)
keypoint_img = draw_keypoints(output, img)
</code></pre>
To translate that to a real-time video setting - we'll use OpenCV to read a video, and run this process for every frame. On each frame, we'll also write the frame into a new file, encoded as a video. This will necessarily slow down the process as we're running the inference, displaying it and writing - so you can speed up the inference and display by avoiding the creation of a new file and writing to it in the loop:
<pre><code class="hljs">def pose_estimation_video(filename):
 cap = cv2.VideoCapture(filename)
 # VideoWriter for saving the video
 fourcc = cv2.VideoWriter_fourcc(*&#x27;MP4V&#x27;)
 out = cv2.VideoWriter(&#x27;ice_skating_output.mp4&#x27;, fourcc, 30.0, (int(cap.get(3)), int(cap.get(4))))
 while cap.isOpened():
 (ret, frame) = cap.read()
 if ret == True:
 frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 output, frame = run_inference(frame)
 frame = draw_keypoints(output, frame)
 frame = cv2.resize(frame, (int(cap.get(3)), int(cap.get(4))))
 out.write(frame)
 cv2.imshow(&#x27;Pose estimation&#x27;, frame)
 else:
 break

 if cv2.waitKey(10) &amp; 0xFF == ord(&#x27;q&#x27;):
 break

 cap.release()
 out.release()
 cv2.destroyAllWindows()
</code></pre>
The <code>VideoWriter</code> accepts several parameters - the output filename, the FourCC (four codec codes, denoting the codec used to encode the video), the frame rate and the resolution as a tuple. To not guess or resize the video - we've used the width and height of the original video, obtained through the <code>VideoCapture</code> instance that contains data about the video itself, such as the width, height, total number of frames, etc.
Now, we can call the method on any input video:
<pre><code class="hljs">pose_estimation_video(&#x27;../ice_skating.mp4&#x27;)
</code></pre>
This will open up an OpenCV window, displaying the inference in real-time. And also, it'll write a video file in the <code>yolov7</code> directory (since we've <code>cd</code>'d into it):
<img src="https://s3.stackabuse.com/media/articles/real-time-pose-estimation-from-video-in-python-with-yolov7.gif" alt="">

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: If your GPU is struggling, or if you want to embed the results of a model like this into an application that has latency as a crucial aspect of the workflow - make the video smaller and work on smaller frames. This is a full HD 1920x1080 video, and should be able to run fast on most home systems, but if it doesn't work as well on your system, make the image(s) smaller.

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at the YOLO method, YOLOv7 and the relationship between YOLO and object detection, pose estimation and instance segmentation. We've then taken a look at how you can easily install and work with YOLOv7 using the programmatic API, and created several convenience methods to make inference and displaying results easier.
Finally, we've opened a video using OpenCV, ran inference with YOLOv7, and made a function for performing pose estimation in real-time, saving the resulting video in full resolution and 30FPS on your local disk.

In this guide, learn how to perform real-time pose estimation (keypoint detection) with state-of-the-art YOLOv7 and OpenCV, in Python, with practical code following good practices.

Real-Time Pose Estimation from Video in Python with YOLOv7

During textual processing, whether you're searching for certain words and making pattern matching rules, counting the frequency of elements, etc. - punctuation can throw a wrench in your plans.
Oftentimes, you'll want to remove stopwords, punctuation, digits or otherwise some category of characters, depending on what your end goal is.
<blockquote>
In this short tutorial, we'll take a look at how to remove punctuation from a string in Java.
</blockquote>
<h2 id="removepunctuationfromstringwithregexregularexpressions">Remove Punctuation from String with RegEx (Regular Expressions)</h2>
Regular Expressions are a very natural fit here, both because they're likely going to be part of other processing parts, and because they're efficient pattern matchers! In Java, the regular expression for matching punctuation is <code>\p{Punct}</code> or a shorthand <code>\p{P}</code>.
You'll have to escape the first backslash in a string, so removing all punctuation is equivalent to matching them and replacing with an empty character:
<pre><code class="hljs">String.replaceAll(&quot;\\p{P}&quot;, &quot;&quot;)
</code></pre>
Let's apply it to a simple sentence:
<pre><code class="hljs">String text = &quot;Hi! This is, in effect, a synthetic sentence. It&#x27;s meant to have several punctuation characters!&quot;;
String clean = text.replaceAll(&quot;\\p{P}&quot;, &quot;&quot;);
System.out.println(clean);
</code></pre>
This results in:
<pre><code class="hljs">Hi This is in effect a synthetic sentence Its meant to have several punctuation characters
</code></pre>
Let's take a look at what characters are treated as punctuation here:
<pre><code class="hljs">String text = &quot;!#$%&amp;&#x27;()*+,-./:;&lt;=&gt;?@[]^_`{|}~&quot;;
String clean = text.replaceAll(&quot;\\p{P}&quot;, &quot;&quot;);
System.out.println(clean);
</code></pre>
With these special characters - which are left after removing punctuation?
<pre><code class="hljs">$+&lt;=&gt;^`|~
</code></pre>
<h2 id="removepunctuationfromstringwithoutregex">Remove Punctuation from String without RegEx</h2>
If you don't want to employ regular expressions, you can do a manual check while iterating through each character of a string. Remember to use a <code>StringBuffer</code> instead of a <code>String</code> while doing this, since strings are immutable and copies need to be made every time you want to add a character - so you'd be creating <code>string.length</code> number of strings in memory.
<code>StringBuffer</code> is mutable, and can be easily converted into an immutable string at the end of the process:
<pre><code class="hljs">public static String removePunctuations(String s) {
 StringBuffer buffer = new StringBuffer();
 for (Character c : s.toCharArray()) {
 if(Character.isLetterOrDigit(c))
 buffer.append(c);
 }
 return buffer.toString();
}
</code></pre>
Let's create a string and clean it:
<pre><code class="hljs">String text = &quot;Hello! \nHere are some special characters: !#$%&amp;&#x27;()*+,-./:;&lt;=&gt;?@[]^_`{|}~ \nWhere are they? :(\n&quot;;
System.out.println(text);
String clean = removePunctuations(text);
System.out.println(clean);
</code></pre>
<pre><code class="hljs">Hello! 
Here are some special characters: !#$%&amp;&#x27;()*+,-./:;&lt;=&gt;?@[]^_`{|}~ 
Where are they? :(

HelloHerearesomespecialcharactersWherearethey
</code></pre>
While this process is more customizable, it only checks for letters and digits. You can check manually for character codes alternatively, and only exclude some punctuation characters instead - and leave in whitespaces, line breaks, etc.
<h2 id="conclusion">Conclusion</h2>
In this short tutorial, we took a look at how you can remove punctuation or certain special characters from a string in Java, using regular expressions or a manual check in an enhanced <code>for</code> loop.

In this short tutorial, learn how to remove punctuation characters and all non-digit/non-characters from a String in Java, using Regular Expressions or an enhanced for loop.

Remove Punctuation From a String in Java

In this practical guide, learn how to perform easy but powerful and fast instance segmentation and object detection in Python with YOLOv7 and Detectron2.

Instance Segmentation with YOLOv7 in Python

In this guide, learn how to perform edge detection in Python and OpenCV with cv2.Canny(). Learn about image gradients, gradient orientation and magnitude, Sorbel and Scharr filters, as well as automated ways to calculate the optimal threshold range for Canny edge detection. Finally, we'll perform real-time edge detection inference on a video and save the resulting video as an MP4 file using OpenCV.

OpenCV Edge Detection in Python with cv2.Canny()

<blockquote>
In this short tutorial, you'll learn how to reverse a list in-place and out-of-place in Java.
</blockquote>
<h2 id="reversinginplaceandoutofplace">Reversing In-Place and Out-Of-Place</h2>
When performing operations on lists - you might want to consider whether the operations are done in-place (changes are enacted on the original object), or whether they're out-of-place (changes are enacted on a copy, and the original object is unchanged).
Some languages and libraries prefer different default behaviors. In Java, most operations on reversing lists will be in-place.
If this is your desired behavior - great! If not, you'll want to create a copy of the list before reversing the copy:
<pre><code class="hljs">List&lt;Integer&gt; list = new ArrayList&lt;&gt;(Arrays.asList(1, 2, 3));
List&lt;Integer&gt; listCopy = new ArrayList&lt;&gt;(list);
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The <code>clone()</code> method doesn't create a deep copy. Creating a list using <code>new ArrayList&lt;&gt;(list)</code> doesn't create a deep copy. Creating deep copies is discouraged, and surprisingly difficult to do in a generic way (and doesn't make sense in some cases, depending on the data type(s) in the list). This won't stop you from being able to reverse <code>list</code> and not have the elements of <code>listCopy</code> being reversed, though.

 </div>
 </div>
 </div>
 <h2 id="collectionsreverse">Collections.reverse()</h2>
The <code>Collections.reverse()</code> method is the standard method for reversing a collection, and acts as the &quot;missing&quot; <code>List.reverse()</code> method. It reverses the list in-place:
<pre><code class="hljs">List&lt;Integer&gt; list = new ArrayList&lt;&gt;(Arrays.asList(1, 2, 3));
List&lt;Integer&gt; listCopy = new ArrayList&lt;&gt;(list);

Collections.reverse(list);

System.out.println(list); // [3, 2, 1]
System.out.println(listCopy); // [1, 2, 3]
</code></pre>
<h2 id="guavaslistsreverselist">Guava's Lists.reverse(list)</h2>
If you're using Google Guava already in your project, you can also leverage the <code>Lists</code> class, which offers the <code>reverse()</code> method, which doesn't sort the original list in-place, but creates a copy and reverses the copy:
<pre><code class="hljs">List&lt;Integer&gt; list = new ArrayList&lt;&gt;(Arrays.asList(1, 2, 3));
List&lt;Integer&gt; reversedList = Lists.reverse(list);

System.out.println(list); // [3, 2, 1]
System.out.println(reversedList); // [1, 2, 3]
</code></pre>
If you don't have it already, you can add Google Guava to your project using Maven, by including its dependency in your <code>pom.xml</code> file:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;com.google.guava&lt;/groupId&gt;
 &lt;artifactId&gt;guava&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
Or via Gradle:
<pre><code class="hljs">implementation group: &#x27;com.google.guava&#x27;, name: &#x27;guava&#x27;
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: If you don't already have Google Guava, or don't intend to use it for other parts of your project - don't import it just for this operation, and stick to the <code>Collections.reverse()</code> method. Guava is a large dependency, and it's a major overkill use it for this operation only.

 </div>
 </div>
 </div>
 <h2 id="listaddandlistremove">List.add() and List.remove()</h2>
If you wish to perform additional operations besides just reversing the list - you can iterate through the original list, remove the elements from the end, pass them through an arbitrary method, and add them back at the start of the list:
<pre><code class="hljs">// Just return the input - placeholder for any other operation
public static int process(int input) {
 return input;
}

List&lt;Integer&gt; list = new ArrayList&lt;&gt;(Arrays.asList(1, 2, 3));

for (int i = 0, j = list.size()-1; i &lt;= j; i++) {
 int lastValue = process(list.remove(j));
 list.add(i, lastValue);
}

System.out.println(list); // [3, 2, 1]
</code></pre>
<h2 id="benchmark">Benchmark</h2>
So, which is the fastest? This also depends on whether you want to perform the operation in-place or out-of-place.
<h3 id="inplacereversalbenchmark">In-Place Reversal Benchmark</h3>
Let's benchmark both approaches on all three of the methods, starting with out-of-place:
<pre><code class="hljs">List&lt;Integer&gt; list = new Random().ints(100, 1, 11)
 .boxed()
 .collect(Collectors.toList());

int runs = 1000;

long start1 = System.currentTimeMillis();
for (int i = 0; i &lt; runs; i++) {
 reverseListCollections(list);
}
long end1 = System.currentTimeMillis();
System.out.println(String.format(&quot;Collections.reverse() took: %s miliseconds&quot;, end1-start1));

long start2 = System.currentTimeMillis();
for (int i = 0; i &lt; runs; i++) {
 reverseListGuava(list);
}
long end2 = System.currentTimeMillis();
System.out.println(String.format(&quot;Guava&#x27;s Lists.reverse() took: %s miliseconds&quot;, end2-start2));

long start3 = System.currentTimeMillis();
for (int i = 0; i &lt; runs; i++) {
 reverseListManually(list);
}
long end3 = System.currentTimeMillis();
System.out.println(String.format(&quot;Manually took: %s miliseconds&quot;, end3-start3));

System.out.println(&quot;Original list: &quot; + list);
</code></pre>
This results in:
<pre><code class="hljs">Collections.reverse() took: 3 miliseconds
Guava&#x27;s Lists.reverse() took: 4 miliseconds
Manually took: 13 miliseconds
Original list: [6, 7, 9, 7, 2, 5, 4, 1, 3, 2, 2, 6, ...
</code></pre>
What happens when we increase the number of elements from 100 to 1000?
<pre><code class="hljs">Collections.reverse() took: 9 miliseconds
Guava&#x27;s Lists.reverse() took: 4 miliseconds
Manually took: 133 miliseconds
Original list: [10, 2, 2, 6, 2, 4, 7, 3, 9, 2, 7, 5, ...
</code></pre>
Guava retains the 4ms mark! The manual approach has the worst time complexity, and it rose linearly. <code>Collections.reverse()</code> suffer less from scaling up, but Guava's implementation suffers the least. Though, keep in mind that we don't manually copy the list for the Guava approach. Will the benchmark change when we ditch the idea of having an &quot;original&quot; and &quot;reversed&quot; list?
<h3 id="outofplacereversalbenchmark">Out-Of-Place Reversal Benchmark</h3>
With 1000 elements, and each operating on a non-reversed copy of the list (which was excluded from the time measurements), when we remove the manual copy from each method and re-run the code:
<pre><code class="hljs">Collections.reverse() took: 7 miliseconds
Guava&#x27;s Lists.reverse() took: 3 miliseconds
Manually took: 131 miliseconds
Original list: [6, 8, 10, 7, 3, 8, 7, 1, 1, 9, 5, ...
</code></pre>
Guava still manages to consistently outperform both <code>Collections.reverse()</code> and the manual approach.
<h2 id="conclusion">Conclusion</h2>
In this short guide, you've learned how to reverse a list in Java, in-place and out-of-place, preserving the original list from the operation. We've used the <code>Collections.reverse()</code> method, Google Guava's <code>Lists.reverse()</code> method and a manual approach.

In this short guide, you'll learn how to reverse a list in Java, in-place and out-of-place, preserving the original list from the operation. We've used the `Collections.reverse()` method, Google Guava's `Lists.reverse()` method and a manual approach.

Reversing a List in Java - In-Place and Out-Of-Place

Jackson is a very common library for handling JSON and serialization/deserialization in general in Java and Spring Boot based projects.
<blockquote>
Jackson handles property names by mapping them as they are to JSON - so <code>propertyName</code> in a POJO will have a corresponding <code>propertyName</code> in JSON. This convention is followed when converting JSON to POJO as well, and if the names don't match, the conversion can't be done.
</blockquote>
However, there are many cases in which you'd want the serialized JSON properties to have different names, such as standardizing naming conventions for other services (using cases like <code>snake_case</code>, instead of <code>CamelCase</code>) or conflicting property names (a <code>Customer</code> can have a <code>firstName</code>, just as an <code>Agent</code> - and a report may contain both of their <code>firstName</code> properties and needs to be serialized).
Let's create a <code>Book</code> class, with a few simple fields:
<pre><code class="hljs">public class Book {
 private String title;
 private String author;
 private int releaseYear;
 
 public Book() {}
 public Book(String title, String author, int releaseYear) {
 this.title = title;
 this.author = author;
 this.releaseYear = releaseYear;
 }
 // Getters, setters, toString(), etc.
}
</code></pre>
<h2 id="changejsonfieldnameswithjackson">Change JSON Field Names with Jackson</h2>
When usually converting an instance of a <code>Book</code> into JSON, we'd write the value of the object as a JSON string using <code>ObjectMapper</code>:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();
Book book = new Book(&quot;Our Mathematical Universe&quot;, &quot;Max Tegmark&quot;, 2014);
 
String jsonBook = mapper.writeValueAsString(book);
System.out.println(jsonBook);
</code></pre>
This results in:
<pre><code class="hljs">{&quot;title&quot;:&quot;Our Mathematical Universe&quot;,&quot;author&quot;:&quot;Max Tegmark&quot;,&quot;releaseYear&quot;:2014}
</code></pre>
The <code>title</code>, <code>author</code> and <code>releaseYear</code> are a 1-to-1 mapping to the <code>title</code>, <code>author</code> and <code>releaseYear</code> fields of the POJO. To change the name of a JSON property and retain it after serialization, there's no need to change your POJO! It's enough to annotate the relevant field with <code>@JsonProperty</code>, and supply the JSON name:
<pre><code class="hljs">public class Book {
 @JsonProperty(&quot;book_title&quot;)
 private String title;
 @JsonProperty(&quot;book_author&quot;)
 private String author;
 @JsonProperty(&quot;book_release_year&quot;)
 private int releaseYear;
 
 public Book(){}
 public Book(String title, String author, int releaseYear) {
 this.title = title;
 this.author = author;
 this.releaseYear = releaseYear;
 }
 // Getters, setters, toString(), etc.
}
</code></pre>
Now, when we instantiate the object and convert it to JSON:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();
Book book = new Book(&quot;Our Mathematical Universe&quot;, &quot;Max Tegmark&quot;, 2014);

String jsonBook = mapper.writeValueAsString(book);
System.out.println(jsonBook);
</code></pre>
The code results in:
<pre><code class="hljs">{&quot;book_title&quot;:&quot;Our Mathematical Universe&quot;,&quot;book_author&quot;:&quot;Max Tegmark&quot;,&quot;book_release_year&quot;:2014}
</code></pre>
<h2 id="changejsonfieldnamesinjsontopojoconversion">Change JSON Field Names in JSON-to-POJO Conversion?</h2>
It's worth noting that the name change isn't one-sided. The same annotation works both ways, and can bridge an incoming JSON with different names into a valid object. For instance, a JSON representing a book with <code>book_title</code>, wouldn't be mapped to the <code>title</code> property of the <code>Book</code> class by default, as they aren't the same.
Since we've annotated <code>title</code> as <code>book_title</code> - the conversion works just fine:
<pre><code class="hljs">Book bookReconstructed = mapper.readValue(jsonBook, Book.class);
System.out.print(bookReconstructed);
</code></pre>
This results in:
<pre><code class="hljs">Book{title=&#x27;Our Mathematical Universe&#x27;, author=&#x27;Max Tegmark&#x27;, releaseYear=2014}
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: To construct an object from JSON, your class needs to have an empty constructor as well. Jackson first instantiates the empty object, and then populates the fields using the getters and setters.

 </div>
 </div>
 </div>
 <h2 id="annotategettersandsetterswithjsonproperty">Annotate Getters and Setters with @JsonProperty</h2>
Do you want to encode different names for serialization and deserialization? For instance, you can serialize <code>Book</code> into a JSON with <code>bt</code> denoting the book's title, but consume JSON with <code>book_title</code>. You can customize the getters and setters of the <code>Book</code> class with <code>@JsonProperty</code> annotations:
<pre><code class="hljs">@JsonProperty(&quot;bt&quot;)
public String getBt() {
 return title;
}

@JsonProperty(&quot;book_title&quot;)
public void setTitle(String title) {
 this.title = title;
}
</code></pre>
This way, when serialized, the <code>getBt()</code> method will serialize the <code>title</code> as a <code>bt</code> field in JSON. When reading from JSON (deserializing), you'll need to supply a <code>book_title</code>, that gets mapped to <code>title</code>.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Both <code>bt</code> and <code>book_title</code> will be mapped to the <code>title</code> field, but this doesn't make <code>bt</code> and <code>book_title</code> interchangeable. Jackson won't be able to convert between them without first converting to <code>title</code>.

 </div>
 </div>
 </div>
 Now, you can instantiate a book, serialize it, and deserialize another String into a book with:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();
Book book = new Book(&quot;Our Mathematical Universe&quot;, &quot;Max Tegmark&quot;, 2014);

// Serialization
String jsonBook = mapper.writeValueAsString(book);
System.out.println(jsonBook);

// Deserialization
String input = &quot;{\&quot;author\&quot;:\&quot;Max Tegmark\&quot;,\&quot;releaseYear\&quot;:2017,\&quot;book_title\&quot;:\&quot;Life 3.0\&quot;}&quot;;
Book bookReconstructed = mapper.readValue(input, Book.class);
System.out.print(bookReconstructed);
</code></pre>
This results in:
<pre><code class="hljs">{&quot;author&quot;:&quot;Max Tegmark&quot;,&quot;releaseYear&quot;:2014,&quot;bt&quot;:&quot;Our Mathematical Universe&quot;}
Book{title=&#x27;Life 3.0&#x27;, author=&#x27;Max Tegmark&#x27;, releaseYear=2017}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short tutorial, we've taken a look at how Jackson maps object fields to JSON, and how you can change the name of the fields before serialization. We've also explored the idea of using different JSON names for serialization and deserialization, using the <code>@JsonProperty</code> annotation on method-level, rather than field-level.

In this short tutorial, learn how to change JSON field names with Jackson in Java, as well as how to handle different JSON names during serialization and deserialization, and how Jackson's mapping between fields and JSON names works.

Change JSON Field Name with Jackson in Java

Jackson is one of the most common libraries for working with serialization and deserialization in Java and Spring Boot, primarily used for parsing and converting between POJOs and JSON.
Though, if you've worked with Jackson, you'll notice a distinct lack of pretty-printing by default:
<pre><code class="hljs">{Task 1=In_Progress, Task 2=Done, Task 3=Planned}
</code></pre>
<blockquote>
In this short tutorial, you'll learn how to pretty-print JSON with Jackson in standard Java and with Spring Boot.
</blockquote>
We'll be working with a JSON string, and a POJO converted into a JSON string, since these behave differently:
<pre><code class="hljs">public class Book {
 private String title;
 private String author;
 private int releaseYear;

 public Book(String title, String author, int releaseYear) {
 this.title = title;
 this.author = author;
 this.releaseYear = releaseYear;
 }
 // Getters, setters, toString(), ...
</code></pre>
Let's instantiate a <code>Book</code> instance, and a string for the input:
<pre><code class="hljs">String inputString = &quot;{\n&quot; +
 &quot;\&quot;Task 1\&quot; : \&quot;In_Progress\&quot;,\n&quot; +
 &quot;\&quot;Task 2\&quot; : \&quot;Done\&quot;,\n&quot; +
 &quot;\&quot;Task 3\&quot; : \&quot;Planned\&quot;\n&quot; +
 &quot;}&quot;;

Book book = new Book(&quot;Our Mathematical Universe&quot;, &quot;Max Tegmark&quot;, 2014);
</code></pre>
<h2 id="prettyprintjsonwithjacksononce">Pretty-Print JSON with Jackson Once</h2>
If you'd like to simply pretty-print once, in a single call, rather than setting the global printing flag - you can simply use the <code>writerWithDefaultPrettyPrinter()</code> call before writing a value as a string:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();

Object jsonString = mapper.readValue(inputString, Object.class);
String indentedString = mapper.writerWithDefaultPrettyPrinter()
 .writeValueAsString(jsonString);
 
 
System.out.println(jsonString);
System.out.println(indentedString);
</code></pre>
The input string was read from (JSON-to-Object), and the value of this object was written back into a string, using pretty-printing (Object-to-JSON):
<pre><code class="hljs">{Task 1=In_Progress, Task 2=Done, Task 3=Planned}

{
 &quot;Task 1&quot; : &quot;In_Progress&quot;,
 &quot;Task 2&quot; : &quot;Done&quot;,
 &quot;Task 3&quot; : &quot;Planned&quot;
}
</code></pre>
Alternatively, when using <code>readTree()</code>, the resulting <code>JsonNode</code> has a <code>toPrettyString()</code> function that serves as a great simple way to convert strings to pretty-printed JSON:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();
Object jsonString = mapper.readTree(inputString).toPrettyString();
System.out.println(jsonString);
</code></pre>
This is a quick and simple way to format an input JSON string! When working with POJOs, instead of reading from a given input, we'll only perform Object-to-JSON conversion and enable pretty-printing:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();

String jsonBook = mapper.writeValueAsString(book);
String indentedBook = mapper.writerWithDefaultPrettyPrinter()
 .writeValueAsString(book);


System.out.println(jsonBook);
System.out.println(indentedBook);
</code></pre>
<pre><code class="hljs">{&quot;title&quot;:&quot;Our Mathematical Universe&quot;,&quot;author&quot;:&quot;Max Tegmark&quot;,&quot;releaseYear&quot;:2014}
{
 &quot;title&quot; : &quot;Our Mathematical Universe&quot;,
 &quot;author&quot; : &quot;Max Tegmark&quot;,
 &quot;releaseYear&quot; : 2014
}
</code></pre>
<h2 id="globalprettyprintsetting">Global Pretty-Print Setting</h2>
Alternatively, you can enable global pretty-printing, if that's the preferable global behavior of Jackson for your project. This is as easy as using the <code>enable()</code> method of the <code>ObjectMapper()</code> instance when you're instantiating it:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper().enable(SerializationFeature.INDENT_OUTPUT);
</code></pre>
As soon as you write an object as a JSON string - pretty-printing will be enabled by default:
<pre><code class="hljs">Object jsonString = mapper.readValue(inputString, Object.class);
String indentedString = mapper.writeValueAsString(jsonString);

System.out.println(jsonString);
System.out.println(indentedString);
</code></pre>
This results in:
<pre><code class="hljs">{Task 1=In_Progress, Task 2=Done, Task 3=Planned}
{
 &quot;Task 1&quot; : &quot;In_Progress&quot;,
 &quot;Task 2&quot; : &quot;Done&quot;,
 &quot;Task 3&quot; : &quot;Planned&quot;
}
</code></pre>
With POJOs:
<pre><code class="hljs">String jsonBook = mapper.writeValueAsString(book);
System.out.println(jsonBook);
</code></pre>
<pre><code class="hljs">{
 &quot;title&quot; : &quot;Our Mathematical Universe&quot;,
 &quot;author&quot; : &quot;Max Tegmark&quot;,
 &quot;releaseYear&quot; : 2014
}
</code></pre>
This approach is significantly less verbose if pretty-printing is a common display format.
<h2 id="prettyprintingjacksonwithspringboot">Pretty-Printing Jackson with Spring Boot</h2>
If you're using Spring Boot, without a manual <code>ObjectMapper</code> instance being created and rely on the underlying serializer, you can set the <code>indent_output</code> flag to <code>true</code> in the <code>application.properties</code> file:
<pre><code class="hljs">spring.jackson.serialization.indent_output=true
</code></pre>
Or, in <code>application.yaml</code>:
<pre><code class="hljs">spring:
 jackson:
 serialization:
 INDENT_OUTPUT: true
</code></pre>
This sets the <code>SerializationFeature.INDENT_OUTPUT</code> flag in Spring's <code>ObjectMapper</code> instance.
<h2 id="conclusion">Conclusion</h2>
In this short tutorial, we've taken a look at how you can pretty-print JSON from a String or POJO using Jackson. We've explored single-print changes (when you only want to pretty-print once) and setting the global Jackson flag for <code>ObjectMapper</code>. Finally, we took a look at changing Spring Boot properties for enabling pretty printing with Jackson.

In this practical tutorial, learn how to enable pretty printing for JSON strings and POJOs when using Jackson, Java and Spring Boot - both once and globally.

Pretty-Printing JSON with Jackson in Java and Spring Boot

<h2 id="introduction">Introduction</h2>
The Adapter Design Pattern is a popular Structural Design Pattern used in software engineering. This guide looks at how we can implement the Adapter Design Pattern in Python.
Design Patterns are template-like solutions - practically recipes for solving recurring, common problems in software development. The Adapter Pattern is based upon the concept of a real-world adapter! For instance, a laptop's charger may have a 3-pin plug at the end, but the wall socket may only be a 2-pin socket. To plug a 3-pin charger into this socket, we'd need an adapter, that accepts a 3-pin plug, and adapts the interface into the 2-pin socket.
A 2-pin charger and a 3-pin charger have the same basic function (conduct electricity from the socket to the laptop), but have a different form, and one can easily adapt into the other. Whenever you have software components with the same basic function but different forms, you can apply the Adapter Design Pattern.
<blockquote>
The Adapter Pattern follows this exact principle. It allows two incompatible interfaces to work together without modifying the internals of each component. This is achieved by adapting one interface, to another, externally.
</blockquote>
Let's look at some basic terminology before diving deeper into the world of Adapter Patterns:
<ul>
<li>Client Interface: An interface that specifies the functions that the client should implement.</li>
<li>Client: A class that implements the client interface.</li>
<li>Adaptee/Service: The incompatible class that needs to collaborate with the client interface.</li>
<li>Adapter: The class that makes the collaboration between the service and the client possible.</li>
</ul>
<h2 id="differenttypesofadapterpatterns">Different Types of Adapter Patterns</h2>
The adapter design pattern can be implemented in two different ways:
<h3 id="objectadapter">Object Adapter</h3>
With this method, the adapter class implements the methods from the client interface. Thus, the client object and the adapter object are compatible with each other. The service object forms a <code>has-a</code> relationship with the adapter object i.e. the service object belongs to the adapter object.
We know that the service class is not compatible with the client. The adapter class wraps around the service object by instantiating itself with that object. Now, the service object can be accessed through the adapter object, allowing the client to interact with it.
We can implement the object adapter in all of the modern programming languages.
<h3 id="classadapter">Class Adapter</h3>
With this method, the adapter has an <code>is-a</code> relationship with the service class. In this scenario, the adapter implements the methods required by the client, but it inherits from multiple adaptees, giving it the ability to call their incompatible functions directly. The biggest drawback with this variation is that we can only use it in the programming languages that support multiple inheritance of classes.
<h2 id="implementationoftheadapterdesignpatterninpython">Implementation of the Adapter Design Pattern in Python</h2>
In the section below, we will implement the Adapter design pattern in Python, specifically using the object adapter variation. The section is divided into two parts. First, we will create the environment where the Adapter Pattern should be used. It's important to see clearly how this pattern can solve some software problems. The second section will use an adapter to resolve the issue.
<h3 id="incompatibilityissuebetweenclasses">Incompatibility Issue Between Classes</h3>
Let's look at the compatibility issue when the client and service class implement different functionalities. Create a client class with the following methods and save it in a folder as <code>car.py</code>:
<pre><code class="hljs">import random

class Car:
 def __init__(self):
 self.generator = random.Random()

 def accelerate(self):
 random_num = self.generator.randint(50, 100)
 speed = random_num
 print(f&quot;The speed of the car is {speed} mph&quot;)

 def apply_brakes(self):
 random_num = self.generator.randint(20, 40)
 speed = random_num
 print(f&quot;The speed of the car is {speed} mph after applying the brakes&quot;)

 def assign_driver(self, driver_name):
 print(f&quot;{driver_name} is driving the car&quot;)
</code></pre>
Here, we have created a <code>Car</code> class with three methods: <code>accelerate()</code>, <code>apply_brakes()</code> and <code>assign_driver()</code>. We imported the <code>random</code> module and used it to generate numbers that set the car's speed after accelerating and applying the brakes. The <code>assign_driver()</code> method displays the car driver's name.
Next, we have to create a service or adaptee class that wishes to collaborate with the client class <code>Car</code>. Create a Motorcycle class like this and save it in your folder as <code>motorcycle.py</code>:
<pre><code class="hljs">import random

class Motorcycle:
 def __init__(self):
 self.generator = random.Random()

 def rev_throttle(self):
 random_num = self.generator.randint(50, 100)
 speed = random_num
 print(f&quot;The speed of the motorcycle is {speed} mph&quot;)

 def pull_brake_lever(self):
 random_num = self.generator.randint(20, 40)
 speed = random_num
 print(
 f&quot;The speed of the motorcycle is {speed} mph after applying the brakes&quot;)

 def assign_rider(self, rider_name):
 print(f&quot;{rider_name} is riding the motorcycle&quot;) 
</code></pre>
A service class, <code>Motorcycle</code> is created above with three methods <code>rev_throttle()</code>, <code>pull_brake_lever()</code>, and <code>assign_rider()</code>. Notice the difference between the methods of the service and client class despite their similar functionality. The <code>accelerator()</code> method increases the speed of the car while the <code>rev_throttle()</code> method increases the motorcycle's speed. Likewise, <code>apply_brakes()</code> and <code>pull_brake_lever()</code> apply brakes in the respective vehicles. Finally, the <code>assign_driver()</code> and <code>assign_rider()</code> methods assign the vehicle operator.
Next, let's create a class to access these different methods. First, add an <code>__init.py__</code> in the same folder you created <code>car.py</code> and <code>motorcycle.py</code>:
<pre><code class="hljs">touch __init__.py
</code></pre>
Now add the following code in a new file <code>drive.py</code>:
<pre><code class="hljs">from car import Car
from motorcycle import Motorcycle
import traceback

if __name__ == &#x27;__main__&#x27;:
 car = Car()
 bike = Motorcycle()

 print(&quot;The Motorcycle\n&quot;)
 bike.assign_rider(&quot;Subodh&quot;)
 bike.rev_throttle()
 bike.pull_brake_lever()
 print(&quot;\n&quot;)

 print(&quot;The Car\n&quot;)
 car.assign_driver(&quot;Sushant&quot;)
 car.accelerate()
 car.apply_brakes()
 print(&quot;\n&quot;)

 print(&quot;Attempting to call client methods with the service object\n&quot;)

 try:
 bike.assign_driver(&quot;Robert&quot;)
 bike.accelerate()
 bike.apply_brakes()
 except AttributeError:
 print(&quot;Oops! bike object cannot access car methods&quot;)
 traceback.print_exc()
</code></pre>
This script creates our client and service objects. We first import the <code>Car</code> and <code>Motorcycle</code> classes and create objects with them. Then we invoke the methods from the <code>bike</code> object (<code>Motorcycle</code> class). After, we invoke the methods of the <code>car</code> object (<code>Car</code> class). When executed, all the code mentioned so far will work.
However, an exception is raised when we try to invoke the methods of the <code>Car</code> class with the <code>bike</code> object. When we run this script:
<pre><code class="hljs">The Motorcycle

Subodh is riding the motorcycle
The speed of the motorcycle is 91 mph
The speed of the motorcycle is 37 mph after applying the brakes


The Car

Sushant is driving the car
The speed of the car is 59 mph
The speed of the car is 33 mph after applying the brakes


Attempting to call client methods with the service object

Oops! bike object cannot access car methods
Traceback (most recent call last):
 File &quot;drive.py&quot;, line 24, in &lt;module&gt;
 bike.assign_driver(&quot;Robert&quot;)
AttributeError: &#x27;Motorcycle&#x27; object has no attribute &#x27;assign_driver&#x27;
</code></pre>
In this case, we can modify the <code>Motorcycle</code> class or the <code>drive.py</code> script to use the right methods. However, in many cases, we may not have access to the source code of the client or service class. Also, this is a simple example. With larger clients and services, it may not be feasible to refactor either of them in case we break compatibility with other systems.
Instead, we can use an adapter to bridge the compatibility gap between our client code and our service object.
<h3 id="usingadapterstosolvetheincompatibilityissue">Using Adapters to Solve the Incompatibility Issue</h3>
In a new file, <code>motorcycle_adapter.py</code>, add the following class:
<pre><code class="hljs">class MotorcycleAdapter:

 def __init__(self, motorcycle):
 self.motorcycle = motorcycle

 def accelerate(self):
 self.motorcycle.rev_throttle()

 def apply_brakes(self):
 self.motorcycle.pull_brake_lever()

 def assign_driver(self, name):
 self.motorcycle.assign_rider(name)
</code></pre>
We created a <code>MotorcycleAdapter</code> class, which instantiates itself with a service object (<code>motorcycle</code>). The adapter implements the client methods which are <code>accelerate()</code>, <code>apply_brakes()</code> and <code>assign_driver()</code>. Inside the body of the <code>accelerate()</code> method, we have used the <code>motorcycle</code> instance of the service object to call the <code>rev_throttle()</code> service method. Likewise, the other methods use the corresponding methods of the <code>Motorcycle</code> class.
Now, let's update <code>drive.py</code> so we can use the adapter in the <code>try/except</code> block:
<pre><code class="hljs">from car import Car
from motorcycle import Motorcycle
from motorcycle_adapter import MotorcycleAdapter # Import the adapter class
import traceback

if __name__ == &#x27;__main__&#x27;:
 car = Car()
 bike = Motorcycle()
 bike_adapter = MotorcycleAdapter(bike) # Create the adapter

 ...

 try:
 print(&quot;Attempting to call client methods with the service object using an adapter\n&quot;)
 bike_adapter.assign_driver(&quot;Robert&quot;)
 bike_adapter.accelerate()
 bike_adapter.apply_brakes()
 except AttributeError:
 print(&quot;Oops! bike object cannot access car methods&quot;)
 traceback.print_exc()
</code></pre>
Here,<code>bike_adapter</code> is an object of the <code>MotorcycleAdapter</code> class. We supplied the <code>bike</code> object to the <code>MotorcycleAdapter</code> class' constructor. Executing this script gives us the following output:
<pre><code class="hljs">The Motorcycle

Subodh is riding the motorcycle
The speed of the motorcycle is 88 mph
The speed of the motorcycle is 35 mph after applying the brakes


The Car

Sushant is driving the car
The speed of the car is 91 mph
The speed of the car is 24 mph after applying the brakes


Attempting to call client methods with the service object

Attempting to call client methods with the service object using an adapter

Robert is riding the motorcycle
The speed of the motorcycle is 67 mph
The speed of the motorcycle is 25 mph after applying the brakes
</code></pre>
Without having to adjust the underlying <code>Motorcycle</code> class, we can get it to work like a <code>Car</code> using an adapter!
<h2 id="prosandconsofadapterdesignpattern">Pros and Cons of Adapter Design Pattern</h2>
The advantages of Adapter Patterns are:
<ul>
<li>We can achieve low coupling between the adapter class and the client class.</li>
<li>We can reuse the adapter class to incorporate numerous service classes in the application.</li>
<li>We can increase the flexibility of the program by introducing multiple adapters without interfering with the client code</li>
</ul>
The disadvantages of Adapter Pattern are:
<ul>
<li>The program's complexity increases with the addition of adapter class and service class.</li>
<li>There is an increase of overhead in the program as the requests are forwarded from one class to another.</li>
<li>Adapter Pattern(class adapter) uses multiple inheritance, which all the programming languages may not support.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
In this article, we learned about the adapter design pattern, its types, and the problems they solve. We implemented the Adapter Pattern in Python so that we can interact with a <code>Motorcycle</code> object, like a <code>Car</code> object by using an adapter so the interface of each class doesn't change.

Guest Contributor

Marcus Sanatan

We'll implement the adapter design pattern in Python so that we can interact with an object with an incompatible interface.