To cut the memory usage to half, in this case you can set the $HistoryLength to 0 which forces Mathematica to not keep copies of the data in the Out list.

For increasing the Import speed, you can save all the images in a multipage tiff file and then import them at once which is a lot faster.

$HistoryLength = 0

You may also use the ParallelMap[] function which uses multiple cores (depending on your license) and is usually faster :

Impimg = ParallelMap[Import[#] &, FileNames["*.bmp"]];

Either removing the "Data" format argument or using "JPEG" instead should do it.

Here is a short example based on the original code.

imgdir = FileNameJoin[{NotebookDirectory[], "Flow pic"}];
(*Export three images for testing purpose*)
SeedRandom[42];
images = ExampleData /@ RandomChoice[ExampleData["TestImage"], 3]
Export[FileNameJoin[{imgdir, "le-" <> ToString[#] <> ".jpg"}], 
   images[[#]], "JPEG"] & /@ Range[3];
FileSystemMap[FileSize, imgdir]
(*Output*)

(*Using Import function with "JPEG" fmt argument*)
imagesA = Import[FileNameJoin[{imgdir, "le-" <> ToString[#] <> ".jpg"}], "JPEG"] & /@ {3, 2, 1};
Map[ImageTake[#, {50, 630}, {499, 600}] &, Map[ImageResize[#, {900, 650}] &, imagesA]]

(*Using Import function w/o fmt argument*)
imagesB = Import[FileNameJoin[{imgdir, "le-" <> ToString[#] <> ".jpg"}]] & /@ {3, 2, 1};
Map[ImageTake[#, {50, 630}, {499, 600}] &, Map[ImageResize[#, {900, 650}] &, imagesB]]
(*Output*)

images = Image /@ ArrayReshape[Import[file, "UnsignedInteger16"], {100, 256, 320}];

Import[FileNameJoin[{"Path", "To", "Directory", "*.jpeg"}], "JPEG"] is undocumented but will work (for now, subject to change).

I recommend perhaps FileSystemMap for this task. Simply Import[#, "JPEG"] & /@ FileNames["/Path/To/Directory/*.jpeg"] will work just fine as well.

Make your filenames unambiguously parsable, e.g. by consistently using some delimeters like underscores or something. A typical file name can look like "Electric_B_3.png". EDIT If you have no control over the file names, use string patterns as described by other answers, but in the long-term you may benefit from creating your own robust naming scheme END EDIT

Then write a function that would parse a single file name, something like:

fileNameParse[fname_String, delim_String: "_"] :=
   StringSplit[FileBaseName[fname], delim]

Then, Map it on FileNames["*.png", {your-dir}].

Finally, apply your importOne on the level one:

importOne@@@Map[fileNameParse, FileNames["*.png", {your-dir}]]

Since you have the result of Map available as well, you can regroup them any way you want. You can, for example, Map a function {#, importOne@@#}&, rather than just using importOne@@@.... Then, you could use GatherBy or any other means to regroup and collect your images according to the parts of their filenames.

EDIT

Here is a self-contained example ( I use text files, but this doesn't matter):

ClearAll[fileNameParse, fileNameMake, importOne, $dir];
fileNameParse[fname_String, delim_String: "_"] :=
    StringSplit[FileBaseName[fname], delim];

fileNameMake[pieces_List, delim_String: "_", ext_String: ".txt"] :=
    StringJoin[Append[Riffle[pieces, "_"], ".txt"]];

importOne[set_, cat_, num_, dir_: $dir] :=
    Import[FileNameJoin[{dir, fileNameMake[{set, cat, num}]}]];

We now create a temporary directory:

$dir = FileNameJoin[{$TemporaryDirectory, "ImportTest"}];
If[! FileExistsQ[$dir], CreateDirectory[$dir]];

Create sample files:

MapIndexed[
   Export[#, "Test" <> ToString[#2], "Text"] &,
   Flatten[
     Outer[
       FileNameJoin[{$dir, fileNameMake[{##}]}] &,
       {"Electric"}, {"A", "B", "C"}, {"1", "2", "3"}
     ]]];

import them:

imported = Map[{#, importOne @@ #} &,  fileNameParse /@ FileNames["*.txt", {$dir}]]

(* 
  ==>

     {{{"Electric", "A", "1"},  "Test{1}"}, {{"Electric", "A", "2"}, "Test{2}"}, 
      {{"Electric", "A", "3"},  "Test{3}"}, {{"Electric", "B", "1"}, "Test{4}"}, 
      {{"Electric", "B", "2"},  "Test{5}"}, {{"Electric", "B", "3"},  "Test{6}"}, 
      {{"Electric", "C", "1"},  "Test{7}"}, {{"Electric", "C", "2"},  "Test{8}"}, 
      {{"Electric", "C", "3"}, "Test{9}"}
      }
*)

You can now, for example, group them according to whatever parts of their file names you wish:

GatherBy[imported , #[[1, 2]] &][[1]]

(* 
 ==>

{{{"Electric", "A", "1"}, "Test{1}"}, {{"Electric", "A", "2"}, "Test{2}"}, 
   {{"Electric", "A", "3"}, "Test{3}"}}

*)

SetDirectory["c:\\users\\rasher\\downloads\\"];
images = FileNames["*.jpg"];
count = 1
Do[imagevar[count++] = Import[image], {image, images}]

Images will be in imagevar[1], imagevar[2]... so you can easily index into them.

Obviously, change directory / filenames to suit.

Let your images lie in /pathtoimages/unchanged/.

Create the folder /pathtoimages/changed/

SetDirectory["/pathtoimages/unchanged/"];
names = FileBaseName /@ FileNames["*.png"];

I'm using the extension png in my example, as I have a bunch of png images somewhere on my machine. If you have photos, they're most likely with the extension jpg - adjust accordingly.

Do[im = Import[name <> ".png"]; 
 Export["../changed/" <> name <> "_blackwhite.png", Binarize[im]];
 Export["../changed/" <> name <> "_grayscale.png", ColorConvert[im, "Grayscale"]];
 , {name, names}]

It's quite slow - took about 30 seconds for 11 files with a total size of 3MB