DEV Community: Piyush Baraskar

LUMEN - Full stack image analysis tool

Piyush Baraskar — Sat, 29 Aug 2026 15:23:56 +0000

Lemme share a half-baked project of mine LUMEN, which I am currently working on.

LUMEN - Full Stack Image Data Analyzer
(will share the link after completing)

It's primarily a learning project, not a platform/SaaS or something.

The basic idea:
The basic idea is simple: give LUMEN an image, and it extracts different properties from it and stores the analysis as structured data.

Working:
The image is first loaded using PIL and converted into a NumPy array. LUMEN then performs different types of analysis, including:

Image dimensions
dtype, std
min/max, mean
RGB channel statistics
Histograms and intensity distribution
Perceptual brightness
Contrast, Sharpness / blur
Colorfulness, Dominant colors
Exposure, Entropy
Duplicate detection

For duplicate detection, I use SHA-256 hashing. The image is hashed and the resulting hash can be used to identify identical files and group duplicates.

Also using pytest to test the analysis functions.

Database side -
Made a persistence layer using PostgreSQL + SQLAlchemy.
The idea is to store the analyzed images and their results as structured records.

For example, an image can have information such as:

ID
filename
dimensions
file information
analysis timestamp

And the analysis can contain things like:

mean brightness
standard deviation
minimum / maximum values
RGB channel statistics
quality metrics

SQLAlchemy ORM is used to represent DB tables as Python models.

Backend — (Work in progress)
The backend is being built with FastAPI,

FastAPI receives the image/request, the analysis engine processes it and the results are validated and structured, and the relevant data is persisted in PostgreSQL.

And the frontend will be made later and then deployment......✌🏼

Still work in progress, but this is where LUMEN is currently at, rn making the backend part :)

Code and approach to solve Subarray sum equals

Piyush Baraskar — Sat, 29 Aug 2026 09:49:44 +0000

class Solution:
    def subarraySum(self, nums: List[int], k: int) -> int:
        prefixsum = 0
        count = 0
        hashmap = {0: 1}

        for i in nums:
            prefixsum += i

            needed = prefixsum - k

            if needed in hashmap:
                count += hashmap[needed]

            if prefixsum in hashmap:
                hashmap[prefixsum] += 1
            else:
                hashmap[prefixsum] = 1

        return count

PROBLEM

so in the ques we have given an array nums and an integer k and we have to return the total number of subarrays whose sum is equal to k.

like here nums = [1,2,3] and k = 3.

the subarrays whose sum is 3 are [1,2] and [3], so the answer will be 2.

APPROACH

so here we use prefixsum and hashmap.

first we calculate the prefixsum while looping through the array.

then we use this formula:

needed = prefixsum - k

because if the current prefixsum is prefixsum and we want a subarray with sum k, then we need a previous prefixsum equal to prefixsum - k.

like nums = [1,2,3] and k = 3.

when we reach 2:

prefixsum = 1 + 2 = 3

so:

needed = 3 - 3 = 0

and 0 is already present in the hashmap, which means the subarray from the beginning [1,2] has sum 3.

then we store the prefixsum in the hashmap and its frequency as the value.

we store frequency instead of just the index because the same prefixsum can appear multiple times, and every previous occurrence can create a different subarray whose sum is k.

also we start with hashmap = {0: 1} because prefixsum 0 exists once before the array starts. this helps us count subarrays that start from index 0.

finally count contains the total number of subarrays whose sum is equal to k.

CODE EXPLAINATION

nums = [1,2,3]

k = 3

prefixsum = 0    -> prefixsum is used to calculate the running prefix sum.
count = 0        -> count stores the total number of subarrays whose sum is equal to k.
hashmap = {0: 1} -> hashmap stores prefixsum as the key and its frequency as the value.


{0: 1} means prefixsum 0 has appeared once before the array started.

for i in nums:
    prefixsum += i

-> looping through every element of nums and adding it to prefixsum.

for nums = [1,2,3] the prefixsum will be:

1 -> 3 -> 6

needed = prefixsum - k

-> calculating which previous prefixsum we need to get a subarray whose sum is k.

the formula is:

previous prefixsum = current prefixsum - k

for example when prefixsum = 3 and k = 3:

needed = 3 - 3 = 0

so we check if prefixsum 0 was seen before.

if needed in hashmap:
    count += hashmap[needed]

-> if needed is present in the hashmap, it means there are previous prefix sums that can create a subarray with sum k.

then we add its frequency to count.

we add the frequency instead of just 1 because the same prefixsum might have appeared multiple times.

if prefixsum in hashmap:
    hashmap[prefixsum] += 1
else:
    hashmap[prefixsum] = 1

-> after checking the needed prefixsum, we store the current prefixsum in the hashmap.

if the prefixsum already exists, increase its frequency by 1.

otherwise create a new key with frequency 1.

return count

-> returns the total number of subarrays whose sum is equal to k.

Code and approach to solve Contiguous array problem

Piyush Baraskar — Sat, 29 Aug 2026 09:47:35 +0000

class Solution:
    def findMaxLength(self, nums: List[int]) -> int:
        arr2 = []
        for i in nums:
            if i == 0:
                arr2.append(-1)
            else :
                arr2.append(1)

        prefixsum = []
        total = 0

        for i in arr2:
            total += i
            prefixsum.append(total)

        hashmap = {0: -1}
        max_length = 0

        for i in range(len(prefixsum)):

            if prefixsum[i] in hashmap:
                length = i - hashmap[prefixsum[i]]
                max_length = max(max_length, length)

            else:
                hashmap[prefixsum[i]] = i

        return max_length

PROBLEM-
so in the ques we have given a binary array and we have to return longest subarray of equal number of 0,1
like here

nums = [0,1,1,1,1,1,0,0,0]

the


 is the longest subarray the numbers are repeating like three ones and then three zeroes and it will return 6 cuz the total number of elements are six 

APPROACH -
so here we are first converting the 0 into -1 because it helps us to calculate the balanced subarray, because when the sum becomes 0 it means there are equal numbers of 0 and 1. like

 ```0,1```

 convert ->

 ```-1,1```

 -> sum = -1 + 1 = 0 -> length = 2

then we calc the prefixsum so we can store the prefixsum according to key value pairs in the hashmap
after that uses the hashmap

then we calc loop through prefix sum index
and if the element is present in hashmap it calc length from i- previous index
and update the max length

else remember its current index

# CODE EXPLAINATION

`nums = [0,1,1,1,1,1,0,0,0]`



```python
arr2 = []

-> creating a blank array to store -1 and 1.

for i in nums:
    if i == 0:
        arr2.append(-1)
    else:
        arr2.append(1)

-> loops through the nums. If element is 0, replace it with -1, otherwise keep it as 1. So arr2 becomes [-1,1,1,1,1,1,-1,-1,-1].

prefixsum = []
total = 0

for i in arr2:
    total += i
    prefixsum.append(total)

-> calculating the prefixsum by adding each element to total and storing the result in prefixsum.

hashmap = {0: -1}
max_length = 0

-> creating a hashmap where prefixsum is the key and its first index is the value. {0: -1} means prefixsum 0 was present before the array started.

for i in range(len(prefixsum)):

-> looping through the prefixsum using its index and calclating the length = current index i - previous index i which is stored in hashmap

if prefixsum[i] in hashmap:
    length = i - hashmap[prefixsum[i]]
    max_length = max(max_length, length)

-> if the current prefixsum is already in the hashmap, it means the sum between the previous index and current index is 0, so the number of 0s and 1s is equal. Then calculate the length and update the max_length.

else:
    hashmap[prefixsum[i]] = i

-> if the prefixsum is not already in the hashmap, store its current index. We store only the first index because it gives the longest possible subarray.

return max_length

-> returns the longest subarray length.

Code and approach to solve Range sum query - immutable problem of leetcode

Piyush Baraskar — Sat, 29 Aug 2026 09:44:20 +0000

class NumArray:

    def __init__(self, nums: List[int]):
        self.prefix = []
        total = 0
        for i in nums:
            total += i
            self.prefix.append(total)

    def sumRange(self, left: int, right: int) -> int:
        if left == 0:
            return self.prefix[right]
        else:
            return self.prefix[right] - self.prefix[left - 1]

So in this problem, we first make a prefix array from the given array. A prefix array stores the sum of all elements from the beginning up to the current index. For example, [1, 2, 3] becomes [1, 3, 6] because 1, 1+2 = 3, and 1+2+3 = 6.

Why prefix sum? Because we have to perform multiple range-sum queries. Instead of calculating the sum again and again for every query, we calculate the cumulative sums once and then use them to get each range sum in O(1) time.

self.prefix = []

→ Creates an empty array to store the prefix sums.

total = 0

→ Stores the running sum. We start with 0 because we haven't added anything yet.

for i in nums:

→ Loops through every element in nums.

total += i

→ Adds the current element to the previous running sum. For [-2, 0, 3, -5, 2, -1], the totals become -2, -2, 1, -4, -2, -3.

self.prefix.append(total)

→ Stores each running total in the prefix array, so we finally get [-2, -2, 1, -4, -2, -3].

if left == 0:

→ Checks if the requested range starts from index 0. For example, sumRange(0, 2).

return self.prefix[right]

→ If left is 0, we don't need to subtract anything. prefix[2] = 1, which is -2 + 0 + 3 = 1.

else:

→ If the range does not start from 0, we need to remove the elements before left.

return self.prefix[right] - self.prefix[left - 1]

→ prefix[right] gives the sum from the beginning up to right, while prefix[left - 1] gives the unwanted part before left. For sumRange(2, 5): prefix[5] - prefix[1] = -3 - (-2) = -1.

How does `self.prefix[right] - self.prefix[left - 1]` work?

Suppose:

nums = [-2, 0, 3, -5, 2, -1]

and the query is:

sumRange(2, 5)

So:

left = 2
right = 5

We want:

3 + (-5) + 2 + (-1) = -1

Our prefix array is:

prefix = [-2, -2, 1, -4, -2, -3]
index     0   1  2   3   4   5

self.prefix[right]

→ Since right = 5, self.prefix[5] = -3. This gives the sum of everything from index 0 to 5:

-2 + 0 + 3 - 5 + 2 - 1 = -3

But we only want the elements from index 2 to 5, so we need to remove the elements before index 2:

-2 + 0 = -2

self.prefix[left - 1]

→ Since left = 2, left - 1 = 1, so self.prefix[1] = -2. This gives the sum of everything before index 2.

Now subtract:

self.prefix[5] - self.prefix[1]

= -3 - (-2)

= -1

And -1 is exactly:

3 + (-5) + 2 + (-1) = -1

In simple words

prefix[right]     → everything up to right
prefix[left - 1]  → unwanted part before left

everything - unwanted part = required range sum

That's why we use:

return self.prefix[right] - self.prefix[left - 1]

Code and approach to solve Contains Duplicate problem of leetcode

Piyush Baraskar — Sat, 29 Aug 2026 09:41:51 +0000

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        seen = set()
        for i in nums:
            if i in seen:
                return True
            else :
                seen.add(i)

        return False

PROBLEM

so in the ques we have given an array nums and we have to check if there is any duplicate element in the array or not.

if any element appears more than one time then we have to return True, otherwise we return False.

like here nums = [1,2,3,1], 1 is present two times so it contains a duplicate and the answer will be True.

but if nums = [1,2,3,4], every element is unique so the answer will be False.

APPROACH

so here we use a set to keep track of the elements that we have already seen.

first we create an empty set called seen.

then we loop through every element of nums.

for every element we check if it is already present in seen.

if it is already present, it means that we have seen this element before, so it is a duplicate and we immediately return True.

otherwise we add that element into seen and continue the loop.

if the complete array is checked and we never find a duplicate, then we return False.

for example nums = [1,2,3,1]:

1 -> not in set -> add 1

2 -> not in set -> add 2

3 -> not in set -> add 3

1 -> already in set -> duplicate found -> return True

CODE EXPLAINATION


python
nums = [1,2,3,1]
seen = set()  -> creating an empty set called seen where we will store the elements that we have already seen.

for i in nums:  -> looping through every element of nums one by one.

if i in seen:
    return True  -> checking if the current element i is already present in seen.

if it is already present, it means the same element appeared before, so it is a duplicate and we return True.

else:
    seen.add(i) -> if the current element is not already present in seen, we add it to the set so we can check it against the upcoming elements.

return False    -> if the loop finishes without finding any duplicate element, it means every element is unique, so we return False.

Code and approach to solve Concatenation of array

Piyush Baraskar — Sat, 29 Aug 2026 09:40:27 +0000

class Solution:
    def getConcatenation(self, nums: List[int]) -> List[int]:
        ans = []

        for i in nums:
            ans.append(i)

        ans += nums

        return ans

PROBLEM

so in the ques we have given an array nums and we have to return the array with itself concatenated. like here nums = [1,2,3] so we have to return [1,2,3,1,2,3]. basically we have to put the same array two times one after another.

APPROACH

so here we first create a blank array ans where we will store the elements.

then we loop through nums and append every element into ans. after that ans already contains the original array.

then we use ans += nums which adds the complete nums array again at the end of ans.

so if nums = [1,2,3]:

ans = [1,2,3]

then ans += nums

ans = [1,2,3,1,2,3]

and finally we return ans.

CODE EXPLAINATION

nums = [1,2,3]

ans = []

creating a blank array to store the elements of nums.

for i in nums:
    ans.append(i)

-> looping through nums and adding every element into ans. So after this loop ans becomes [1,2,3].

ans += nums

-> adding the complete nums array again at the end of ans. So ans becomes [1,2,3,1,2,3].

return ans

-> returns the concatenated array [1,2,3,1,2,3].

Code and approach to so solve Longest common prefix

Piyush Baraskar — Wed, 26 Aug 2026 22:40:28 +0000

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        Longest_sum = ""

        for i in range(len(strs[0])):
            for j in strs:
                if i >= len(j) or j[i] != strs[0][i]:
                    return Longest_sum

            Longest_sum += strs[0][i]

        return Longest_sum

PROBLEM

so in the ques we have given an array of strings strs and we have to find the longest common prefix among all the strings.

prefix means the characters that come at the starting of the string.

like here strs = ["flower","flow","flight"].

the common starting characters are f, l, so the longest common prefix is "fl".

therefore the answer will be "fl".

APPROACH

so here we create an empty string Longest_sum where we will store the common prefix.

then we loop through the characters of the first string because we can use the first string as a reference and compare its characters with all the other strings.

then inside that loop, we loop through every string in strs.

for every string we check two conditions:

i >= len(j)

this checks if the current index i is outside the length of the current string. If it is, then there cannot be any common prefix at this position.

and:

j[i] != strs[0][i]

this checks if the current character of the string is different from the character at the same position in the first string.

if either condition is true, it means the common prefix has ended, so we return Longest_sum.

if the character is the same in every string, we add that character to Longest_sum and continue checking the next character.

for example:

strs = ["flower","flow","flight"]

first character:

f == f == f -> add f

second character:

l == l == l -> add l

third character:

o == o but o != i -> stop

so Longest_sum = "fl" and we return "fl".

CODE EXPLAINATION

strs = ["flower","flow","flight"]

Longest_sum = ""  -> creating an empty string Longest_sum where we will store the common prefix.

for i in range(len(strs[0])): -> looping through the indices of the first string.

we use the first string as a reference and check its characters against all the other strings.
for strs = ["flower","flow","flight"], the loop checks index 0, 1, 2, and so on.

for j in strs:  -> looping through every string in strs so we can compare the character at index i with the character from the first string.

if i >= len(j) or j[i] != strs[0][i]:
    return Longest_sum  -> checking if the current index is outside the length of the current string or if the characters are different.

i >= len(j) means the current string is shorter and does not have a character at index i.

j[i] != strs[0][i] means the current character is different from the character at the same position in the first string.

if either condition is true, the common prefix ends here, so we return Longest_sum.

Longest_sum += strs[0][i]  -> if the current character is the same in every string, we add that character to Longest_sum.

for example:

Longest_sum = ""

then f -> "f"

then l -> "fl"

then when the characters don't match, we return "fl".

return Longest_sum  -> if we finish checking the first string without finding a mismatch, we return the complete Longest_sum as the longest common prefix.

My Code and approach to solve the two sum problem of leetcode

Piyush Baraskar — Wed, 26 Aug 2026 22:36:40 +0000

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            for j in range(len(nums)):
                if i != j and nums[i] + nums[j] == target:
                    return [i, j]

PROBLEM

so in the ques we have given an array nums and an integer target and we have to find two different elements whose sum is equal to target.

we have to return the indices of those two elements.

like here nums = [2,7,11,15] and target = 9.

here 2 + 7 = 9, so the indices are 0 and 1, therefore the answer will be [0,1].

APPROACH

so here we use two loops to check every possible pair of elements in the array.

first loop takes one element using index i.

then second loop takes another element using index j.

we check two conditions:

i != j

this makes sure that we are not using the same element twice.

and:

nums[i] + nums[j] == target

this checks if the sum of the two elements is equal to the target.

if both conditions are true, we return their indices [i,j].

for example nums = [2,7,11,15] and target = 9:

2 + 2 -> not allowed because i == j

2 + 7 = 9 -> target found

so we return [0,1].

CODE EXPLAINATION

``
nums = [2,7,11,15]

target = 9

for i in range(len(nums)): -> first loop through the indices of nums.

for nums = [2,7,11,15], i will be 0, 1, 2, and 3.

for j in range(len(nums)): -> second loop also goes through all the indices of nums,this allows us to check every possible pair of elements.

if i != j and nums[i] + nums[j] == target: -> checking two conditions.

i != j means the two indices must be different, so we don't use the same element twice.

nums[i] + nums[j] == target checks if the sum of the two elements is equal to target.

return [i, j] -> if we find two elements whose sum is equal to the target, we return their indices.

for example:

nums[0] + nums[1]

2 + 7 = 9

so it returns [0,1].
``

WHAT'S HISTOGRAM ? A histogram shows how pixel intensity is distributed in image. I calculate it to understand how much of image is dark, mid-tone or bright Using NumPy to count pixel val into 256 bins then convert those regions into % for easier analysis

Piyush Baraskar — Thu, 20 Aug 2026 20:25:45 +0000

So I had an image analyzer project that was like a Py script using PIL + NumPy to analyze images. Months later, I reopened the repo and thought makin a real project So far proper structure, tests, better analysis, JSON/CSV exports, and now makin backend

Piyush Baraskar — Thu, 20 Aug 2026 05:31:10 +0000

How RAG works

Piyush Baraskar — Tue, 11 Aug 2026 19:14:30 +0000

Learned about RAG Retrieval augmented generation
Which is used when a model need external data on which the data is not trained it is where Rag is used

Llm is not fine tuned instead the external data is divided into smaller chunks. Each chunk is converted into an embedding and is stored in the vector databases and the model can retrieve which chunk of info to used depending on the prompt

Now check
Each chunk is embedded

It is used when you.want to add your own data on the llm

DEV Community: Piyush Baraskar

LUMEN - Full stack image analysis tool

Code and approach to solve Subarray sum equals

PROBLEM

APPROACH

CODE EXPLAINATION

Code and approach to solve Contiguous array problem

Code and approach to solve Range sum query - immutable problem of leetcode

How does self.prefix[right] - self.prefix[left - 1] work?

In simple words

Code and approach to solve Contains Duplicate problem of leetcode

PROBLEM

APPROACH

CODE EXPLAINATION

Code and approach to solve Concatenation of array

PROBLEM

APPROACH

CODE EXPLAINATION

Code and approach to so solve Longest common prefix

PROBLEM

APPROACH

CODE EXPLAINATION

My Code and approach to solve the two sum problem of leetcode

PROBLEM

APPROACH

CODE EXPLAINATION

WHAT'S HISTOGRAM ? A histogram shows how pixel intensity is distributed in image. I calculate it to understand how much of image is dark, mid-tone or bright Using NumPy to count pixel val into 256 bins then convert those regions into % for easier analysis

So I had an image analyzer project that was like a Py script using PIL + NumPy to analyze images. Months later, I reopened the repo and thought makin a real project So far proper structure, tests, better analysis, JSON/CSV exports, and now makin backend

How RAG works

How does `self.prefix[right] - self.prefix[left - 1]` work?