Check if the given point lies inside given N points of a Convex Polygon

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class GFG {
    // Function To Check Clockwise Orientation
    static boolean cw(int[] a, int[] b, int[] c)
    {
        int p = a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1])
                + c[0] * (a[1] - b[1]);

        return p < 0;
    }

    // Function To Check Counter Clockwise Orientation
    static boolean ccw(int[] a, int[] b, int[] c)
    {
        int p = a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1])
                + c[0] * (a[1] - b[1]);

        return p > 0;
    }

    // Graham Scan Algorithm To Find Convex Hull From Given
    // Points
    static int[][] convexHull(int[][] v)
    {
        // Sort The Points
        Arrays.sort(v, (a, b) -> a[0] - b[0]);

        int n = v.length;
        if (n <= 3) {
            return v;
        }

        // Set Starting And Ending Points As Left Bottom And
        // Top Right
        int[] p1 = v[0];
        int[] p2 = v[n - 1];

        // Vector To Store Points In Upper Half And Lower
        // Half
        List<int[]> up = new ArrayList<int[]>();
        List<int[]> down = new ArrayList<int[]>();

        // Insert Starting/Ending Points
        up.add(p1);
        down.add(p1);

        // Iterate Over Points
        for (int i = 1; i < n; i++) {
            if (i == n - 1 || !ccw(p1, v[i], p2)) {
                while (up.size() > 1
                       && ccw(up.get(up.size() - 2),
                              up.get(up.size() - 1),
                              v[i])) {
                    // Exclude This Point If We Can Form
                    // Better
                    up.remove(up.size() - 1);
                }

                up.add(v[i]);
            }

            if (i == n - 1 || !cw(p1, v[i], p2)) {
                while (down.size() > 1
                       && cw(down.get(down.size() - 2),
                             down.get(down.size() - 1),
                             v[i])) {
                    // Exclude This Point If We Can Form
                    // Better
                    down.remove(down.size() - 1);
                }

                down.add(v[i]);
            }
        }

        // Combine Upper And Lower Half
        for (int i = down.size() - 2; i >= 0; i--) {
            up.add(down.get(i));
        }

        // Return The Points On Convex Hull
        return up.toArray(new int[0][]);
    }

    // Function To Find If Point Lies Inside A convex
    // polygon
    static boolean isInside(int[][] points, int[] query)
    {
        // Include the query point in the
        // polygon points
        int[][] points1 = new int[points.length + 1][];
        for (int i = 0; i < points.length; i++)
            points1[i] = points[i];
        points1[points.length] = query;

        // Form a convex hull from the points
        points = convexHull(points);

        // Iterate over the points
        // of convex hull
        for (int[] x : points) {

            // If the query point lies
            // on the convex hull
            // then it wasn't inside
            if (Arrays.equals(x, query))
                return false;
        }

        // Otherwise it was Inside
        return true;
    }

    // Driver Code

    public static void main(String[] args)
    {
        // Points of the polygon
        // given in any order
        int n = 7;
        int[][] points
            = { new int[] { 1, 1 }, new int[] { 2, 1 },
                new int[] { 3, 1 }, new int[] { 4, 1 },
                new int[] { 4, 2 }, new int[] { 4, 3 },
                new int[] { 4, 4 } };

        // Query Points
        int[] query = { 3, 2 };

        // Check if its inside
        if (isInside(points, query)) {
            System.out.println("YES");
        }
        else {
            System.out.println("NO");
        }
    }
}